 (Half Day),
 and year: ,
""" does not exists","""Nu există"
%  Delivered,Livrat%
% Amount Billed,% Suma facturată
% Billed,Taxat%
% Completed,% Finalizat
% Delivered,Livrat%
% Installed,Instalat%
% Received,Primit%
% of materials billed against this Purchase Order.,% Din materiale facturat împotriva acestei Comandă.
% of materials billed against this Sales Order,% Din materiale facturate împotriva acestui ordin de vânzări
% of materials delivered against this Delivery Note,% Din materiale livrate de această livrare Nota
% of materials delivered against this Sales Order,% Din materiale livrate de această comandă de vânzări
% of materials ordered against this Material Request,% Din materiale comandate în această cerere Material
% of materials received against this Purchase Order,% Din materiale au primit în această Comandă
'Actual Start Date' can not be greater than 'Actual End Date',"""Data de începere efectivă"" nu poate fi mai mare decât ""Actual Data de încheiere"""
'Based On' and 'Group By' can not be same,"""Bazat pe"" și ""grup de"" nu poate fi același"
'Days Since Last Order' must be greater than or equal to zero,"""Zile de la ultima comandă"" trebuie să fie mai mare sau egal cu zero"
'Entries' cannot be empty,"""Intrările"" nu poate fi gol"
'Expected Start Date' can not be greater than 'Expected End Date',"""Data de începere așteptată"" nu poate fi mai mare decât ""Date End așteptat"""
'From Date' is required,"""De la data"" este necesară"
'From Date' must be after 'To Date',"""De la data"" trebuie să fie după ""To Date"""
'Has Serial No' can not be 'Yes' for non-stock item,"""Nu are de serie"" nu poate fi ""Da"" pentru element non-stoc"
'Notification Email Addresses' not specified for recurring invoice,"""notificare adrese de email"", care nu sunt specificate pentru factura recurente"
'Profit and Loss' type account {0} not allowed in Opening Entry,"De tip ""Profit și pierdere"" cont {0} nu este permis în deschidere de intrare"
'To Case No.' cannot be less than 'From Case No.',"""În caz nr"" nu poate fi mai mică decât ""Din cauza nr"""
'To Date' is required,"""Pentru a Data"" este necesară"
'Update Stock' for Sales Invoice {0} must be set,"""Actualizare Stock"" pentru Vânzări Factura {0} trebuie să fie stabilite"
* Will be calculated in the transaction.,* Vor fi calculate în tranzacție.
"1 Currency = [?] Fraction
For e.g. 1 USD = 100 Cent","1 valutar = [?] Fractiune 
 De exemplu, 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 Pentru a menține codul de client element înțelept și pentru a le face pe baza utilizării lor cod de această opțiune
"<a href=""#Sales Browser/Customer Group"">Add / Edit</a>","<a href=""#Sales Browser/Customer Group""> Add / Edit </ a>"
"<a href=""#Sales Browser/Item Group"">Add / Edit</a>","<a href=""#Sales Browser/Item Group""> Add / Edit </ a>"
"<a href=""#Sales Browser/Territory"">Add / Edit</a>","<a href=""#Sales Browser/Territory""> Add / Edit </ 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> implicit Format </ h4> 
 <p> Utilizeaza <a href=""http://jinja.pocoo.org/docs/templates/""> Jinja templating </ a> și toate domeniile de Adresa ( inclusiv Câmpuri personalizate dacă este cazul) va fi disponibil </ p> 
 <pre> <code> {{}} address_line1 <br> 
 {% dacă address_line2%} {{}} address_line2 cui { % endif -%} 
 {{oras}} <br> 
 {%, în cazul în care de stat%} {{}} stat {cui% endif -%} 
 {%, în cazul în care parola așa%} PIN: {{}} parola așa cui {% endif -%} 
 {{țară}} <br> 
 {%, în cazul în care telefonul%} Telefon: {{telefon}} cui { % endif -%} 
 {% dacă fax%} Fax: {{fax}} cui {% endif -%} 
 {% dacă 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,Există un grup de clienți cu același nume vă rugăm să schimbați numele clientului sau redenumi Grupul Customer
A Customer exists with same name,Există un client cu același nume
A Lead with this email id should exist,Un plumb cu acest id-ul de e-mail ar trebui să existe
A Product or Service,Un produs sau serviciu
A Supplier exists with same name,Un furnizor există cu același nume
A symbol for this currency. For e.g. $,"Un simbol pentru această monedă. De exemplu, $"
AMC Expiry Date,AMC Data expirării
Abbr,Abbr
Abbreviation cannot have more than 5 characters,Abreviere nu poate avea mai mult de 5 caractere
Above Value,Valoarea de mai sus
Absent,Absent
Acceptance Criteria,Criteriile de acceptare
Accepted,Acceptat
Accepted + Rejected Qty must be equal to Received quantity for Item {0},Acceptat Respins + Cantitate trebuie să fie egală cu cantitatea primite pentru postul {0}
Accepted Quantity,Acceptat Cantitate
Accepted Warehouse,Depozit acceptate
Account,Cont
Account Balance,Soldul contului
Account Created: {0},Cont creat: {0}
Account Details,Detalii cont
Account Head,Cont Șeful
Account Name,Nume cont
Account Type,Tip de cont
"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Soldul contului deja în credit, tu nu sunt permise pentru a seta ""Balanța trebuie să fie"" la fel de ""debit"""
"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Soldul contului deja în debit, nu vi se permite să stabilească ""Balanța trebuie să fie"" drept ""credit"""
Account for the warehouse (Perpetual Inventory) will be created under this Account.,Cont de depozit (Inventar Perpetual) va fi creat sub acest cont.
Account head {0} created,Cap cont {0} a creat
Account must be a balance sheet account,Contul trebuie să fie un cont de bilanț
Account with child nodes cannot be converted to ledger,Cont cu noduri copil nu pot fi convertite în registrul
Account with existing transaction can not be converted to group.,Cont cu tranzacții existente nu pot fi convertite în grup.
Account with existing transaction can not be deleted,Cont cu tranzacții existente nu pot fi șterse
Account with existing transaction cannot be converted to ledger,Cont cu tranzacții existente nu pot fi convertite în registrul
Account {0} cannot be a Group,Contul {0} nu poate fi un grup
Account {0} does not belong to Company {1},Contul {0} nu aparține companiei {1}
Account {0} does not belong to company: {1},Contul {0} nu apartine companiei: {1}
Account {0} does not exist,Contul {0} nu există
Account {0} has been entered more than once for fiscal year {1},Contul {0} a fost introdus mai mult de o dată pentru anul fiscal {1}
Account {0} is frozen,Contul {0} este înghețat
Account {0} is inactive,Contul {0} este inactiv
Account {0} is not valid,Contul {0} nu este valid
Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,"Contul {0} trebuie să fie de tip ""active fixe"", ca Item {1} este un element activ"
Account {0}: Parent account {1} can not be a ledger,Contul {0}: cont Părinte {1} nu poate fi un registru
Account {0}: Parent account {1} does not belong to company: {2},Contul {0}: cont Părinte {1} nu apartine companiei: {2}
Account {0}: Parent account {1} does not exist,Contul {0}: cont Părinte {1} nu exista
Account {0}: You can not assign itself as parent account,Contul {0}: Nu se poate atribui ca cont părinte
"Account: {0} can only be updated via \
					Stock Transactions","Cont: {0} poate fi actualizat doar prin \
 Tranzacții stoc"
Accountant,Contabil
Accounting,Contabilitate
"Accounting Entries can be made against leaf nodes, called","Înregistrări contabile pot fi făcute împotriva nodurile frunză, numit"
"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Intrare contabilitate congelate până la această dată, nimeni nu poate face / modifica intrare cu excepția rol specificate mai jos."
Accounting journal entries.,Intrări de jurnal de contabilitate.
Accounts,Conturi
Accounts Browser,Conturi Browser
Accounts Frozen Upto,Conturile înghețate Până la
Accounts Payable,Conturi de plată
Accounts Receivable,Conturi de încasat
Accounts Settings,Conturi Setări
Active,Activ
Active: Will extract emails from ,
Activity,Activități
Activity Log,Activitate Log
Activity Log:,Activitate Log:
Activity Type,Activitatea de Tip
Actual,Real
Actual Budget,Bugetul actual
Actual Completion Date,Real Finalizarea Data
Actual Date,Data efectivă
Actual End Date,Real Data de încheiere
Actual Invoice Date,Real Data facturii
Actual Posting Date,Real Dată postare
Actual Qty,Real Cantitate
Actual Qty (at source/target),Real Cantitate (la sursă / țintă)
Actual Qty After Transaction,Real Cantitate După tranzacție
Actual Qty: Quantity available in the warehouse.,Cantitate real: Cantitate disponibil în depozit.
Actual Quantity,Real Cantitate
Actual Start Date,Data efectivă Start
Add,Adaugă
Add / Edit Taxes and Charges,Adauga / Editare Impozite și Taxe
Add Child,Adăuga copii
Add Serial No,Adauga ordine
Add Taxes,Adauga Impozite
Add Taxes and Charges,Adauga impozite și taxe
Add or Deduct,Adăuga sau deduce
Add rows to set annual budgets on Accounts.,Adauga rânduri pentru a seta bugete anuale pe Conturi.
Add to Cart,Adauga in cos
Add to calendar on this date,Adauga la calendar la această dată
Add/Remove Recipients,Add / Remove Destinatari
Address,Adresă
Address & Contact,Adresa și date de contact
Address & Contacts,Adresa & Contact
Address Desc,Adresa Descărca
Address Details,Detalii Adresa
Address HTML,Adresa HTML
Address Line 1,Adresa Linia 1
Address Line 2,Adresa Linia 2
Address Template,Format adresa
Address Title,Adresa Titlu
Address Title is mandatory.,Adresa Titlul este obligatoriu.
Address Type,Adresa Tip
Address master.,Maestru adresa.
Administrative Expenses,Cheltuieli administrative
Administrative Officer,Ofițer administrativ
Advance Amount,Advance Suma
Advance amount,Sumă în avans
Advances,Avans
Advertisement,Publicitate
Advertising,Reclamă
Aerospace,Aerospace
After Sale Installations,După Vanzare Instalatii
Against,Împotriva
Against Account,Împotriva contului
Against Bill {0} dated {1},Împotriva Bill {0} din {1}
Against Docname,Împotriva Docname
Against Doctype,Împotriva Doctype
Against Document Detail No,Împotriva Document Detaliu Nu
Against Document No,Împotriva Documentul nr
Against Expense Account,Împotriva cont de cheltuieli
Against Income Account,Împotriva contul de venit
Against Journal Voucher,Împotriva Jurnalul Voucher
Against Journal Voucher {0} does not have any unmatched {1} entry,Împotriva Jurnalul Voucher {0} nu are nici neegalat {1} intrare
Against Purchase Invoice,Împotriva cumparare factură
Against Sales Invoice,Împotriva Factura Vanzare
Against Sales Order,Împotriva comandă de vânzări
Against Voucher,Împotriva Voucher
Against Voucher Type,Împotriva Voucher Tip
Ageing Based On,Îmbătrânirea Bazat pe
Ageing Date is mandatory for opening entry,Îmbătrânirea Data este obligatorie pentru deschiderea de intrare
Ageing date is mandatory for opening entry,Data Îmbătrânirea este obligatorie pentru deschiderea de intrare
Agent,Agent
Aging Date,Îmbătrânire Data
Aging Date is mandatory for opening entry,Aging Data este obligatorie pentru deschiderea de intrare
Agriculture,Agricultură
Airline,Linie aeriană
All Addresses.,Toate adresele.
All Contact,Toate Contact
All Contacts.,Toate persoanele de contact.
All Customer Contact,Toate Clienți Contact
All Customer Groups,Toate grupurile de clienți
All Day,All Day
All Employee (Active),Toate Angajat (Activ)
All Item Groups,Toate Articol Grupuri
All Lead (Open),Toate plumb (Open)
All Products or Services.,Toate produsele sau serviciile.
All Sales Partner Contact,Toate vânzările Partener Contact
All Sales Person,Toate vânzările Persoana
All Supplier Contact,Toate Furnizor Contact
All Supplier Types,Toate tipurile de Furnizor
All Territories,Toate teritoriile
"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.","Domenii legate de toate de export, cum ar fi moneda, rata de conversie, numărul total export, export mare etc totală sunt disponibile în nota de livrare, POS, cotatie, Factura Vanzare, comandă de vânzări, etc"
"All import related fields like currency, conversion rate, import total, import grand total etc are available in Purchase Receipt, Supplier Quotation, Purchase Invoice, Purchase Order etc.","Toate domeniile legate de import, cum ar fi moneda, rata de conversie, total de import, de import de mare etc totală sunt disponibile în Primirea de cumparare, furnizor cotatie, cumparare factură, Ordinul de cumparare, etc"
All items have already been invoiced,Toate elementele au fost deja facturate
All these items have already been invoiced,Toate aceste elemente au fost deja facturate
Allocate,Alocarea
Allocate leaves for a period.,Alocați frunze pentru o perioadă.
Allocate leaves for the year.,Alocarea de frunze pentru anul.
Allocated Amount,Suma alocată
Allocated Budget,Bugetul alocat
Allocated amount,Suma alocată
Allocated amount can not be negative,Suma alocată nu poate fi negativ
Allocated amount can not greater than unadusted amount,Suma alocată nu poate mai mare decât valoarea unadusted
Allow Bill of Materials,Permite Bill de materiale
Allow Bill of Materials should be 'Yes'. Because one or many active BOMs present for this item,"Permite Bill de materiale ar trebui să fie ""Da"". Deoarece unul sau mai multe BOM active prezente pentru acest articol"
Allow Children,Permiteți copii
Allow Dropbox Access,Dropbox permite accesul
Allow Google Drive Access,Permite accesul Google Drive
Allow Negative Balance,Permite sold negativ
Allow Negative Stock,Permiteți Stock negativ
Allow Production Order,Permiteți producție Ordine
Allow User,Permite utilizatorului
Allow Users,Se permite utilizatorilor
Allow the following users to approve Leave Applications for block days.,Permite următoarele utilizatorilor să aprobe cererile de concediu pentru zile bloc.
Allow user to edit Price List Rate in transactions,Permite utilizatorului să editeze Lista de preturi Rate în tranzacții
Allowance Percent,Alocație Procent
Allowance for over-{0} crossed for Item {1},Reduceri pentru mai mult de-{0} a trecut pentru postul {1}
Allowance for over-{0} crossed for Item {1}.,Reduceri pentru mai mult de-{0} a trecut pentru postul {1}.
Allowed Role to Edit Entries Before Frozen Date,Rolul permisiunea de a edita intrările înainte de Frozen Data
Amended From,A fost modificat de la
Amount,Suma
Amount (Company Currency),Suma (Compania de valuta)
Amount Paid,Suma plătită
Amount to Bill,Se ridică la Bill
An Customer exists with same name,Există un client cu același nume
"An Item Group exists with same name, please change the item name or rename the item group","Există un grup articol cu același nume, vă rugăm să schimbați numele elementului sau redenumi grupul element"
"An item exists with same name ({0}), please change the item group name or rename the item","Un element există cu același nume ({0}), vă rugăm să schimbați numele grupului element sau redenumi elementul"
Analyst,Analist
Annual,Anual
Another Period Closing Entry {0} has been made after {1},O altă intrare Perioada inchiderii {0} a fost făcută după ce {1}
Another Salary Structure {0} is active for employee {0}. Please make its status 'Inactive' to proceed.,"Un alt Structura Salariul {0} este activ pentru angajat {0}. Vă rugăm să vă statutul de ""inactiv"" pentru a continua."
"Any other comments, noteworthy effort that should go in the records.","Orice alte comentarii, efort demn de remarcat faptul că ar trebui să meargă în înregistrările."
Apparel & Accessories,Îmbrăcăminte și accesorii
Applicability,Aplicabilitate
Applicable For,Aplicabil pentru
Applicable Holiday List,Aplicabil Lista de vacanță
Applicable Territory,Teritoriul de aplicare
Applicable To (Designation),Aplicabile (denumirea)
Applicable To (Employee),Aplicabile (Angajat)
Applicable To (Role),Aplicabile (rol)
Applicable To (User),Aplicabile (User)
Applicant Name,Nume solicitant
Applicant for a Job.,Solicitant pentru un loc de muncă.
Application of Funds (Assets),Aplicarea fondurilor (activelor)
Applications for leave.,Cererile de concediu.
Applies to Company,Se aplică de companie
Apply On,Se aplică pe
Appraisal,Evaluare
Appraisal Goal,Evaluarea Goal
Appraisal Goals,Obiectivele de evaluare
Appraisal Template,Evaluarea Format
Appraisal Template Goal,Evaluarea Format Goal
Appraisal Template Title,Evaluarea Format Titlu
Appraisal {0} created for Employee {1} in the given date range,Evaluarea {0} creat pentru Angajat {1} la dat intervalul de date
Apprentice,Ucenic
Approval Status,Starea de aprobare
Approval Status must be 'Approved' or 'Rejected',"Starea de aprobare trebuie să fie ""Aprobat"" sau ""Respins"""
Approved,Aprobat
Approver,Denunțător
Approving Role,Aprobarea Rolul
Approving Role cannot be same as role the rule is Applicable To,Aprobarea rol nu poate fi la fel ca rolul statului este aplicabilă
Approving User,Aprobarea utilizator
Approving User cannot be same as user the rule is Applicable To,Aprobarea Utilizatorul nu poate fi aceeași ca și utilizator regula este aplicabilă
Are you sure you want to STOP ,
Are you sure you want to UNSTOP ,
Arrear Amount,Restanță Suma
"As Production Order can be made for this item, it must be a stock item.","Ca producție Ordine pot fi făcute pentru acest articol, trebuie să fie un element de stoc."
As per Stock UOM,Ca pe 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'","Așa cum există tranzacții bursiere existente pentru acest element, nu puteți modifica valorile ""nu are nici un Serial"", ""Este Piesa"" și ""Metoda de evaluare"""
Asset,Asset
Assistant,Asistent
Associate,Asociat
Atleast one of the Selling or Buying must be selected,Cel putin una din vânzarea sau cumpărarea trebuie să fie selectată
Atleast one warehouse is mandatory,Cel putin un antrepozit este obligatorie
Attach Image,Atașați Image
Attach Letterhead,Atașați cu antet
Attach Logo,Atașați Logo
Attach Your Picture,Atașați imaginea
Attendance,Prezență
Attendance Date,Spectatori Data
Attendance Details,Detalii de participare
Attendance From Date,Participarea la data
Attendance From Date and Attendance To Date is mandatory,Participarea la data și prezență până în prezent este obligatorie
Attendance To Date,Participarea la Data
Attendance can not be marked for future dates,Spectatori nu pot fi marcate pentru date viitoare
Attendance for employee {0} is already marked,Spectatori pentru angajat {0} este deja marcat
Attendance record.,Record de participare.
Authorization Control,Controlul de autorizare
Authorization Rule,Regula de autorizare
Auto Accounting For Stock Settings,Contabilitate Auto Pentru Stock Setări
Auto Material Request,Material Auto Cerere
Auto-raise Material Request if quantity goes below re-order level in a warehouse,Auto-raise Material cerere în cazul în care cantitatea scade sub nivelul de re-comandă într-un depozit
Automatically compose message on submission of transactions.,Compune în mod automat un mesaj pe prezentarea de tranzacții.
Automatically extract Job Applicants from a mail box ,
Automatically extract Leads from a mail box e.g.,"Extrage automat Oportunitati de la o cutie de e-mail de exemplu,"
Automatically updated via Stock Entry of type Manufacture/Repack,Actualizat automat prin Bursa de intrare de tip Fabricarea / Repack
Automotive,Automotive
Autoreply when a new mail is received,Răspuns automat atunci când un nou e-mail este primit
Available,Disponibil
Available Qty at Warehouse,Cantitate disponibil la Warehouse
Available Stock for Packing Items,Disponibil Stock pentru ambalare Articole
"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet","Disponibil în BOM, nota de livrare, factura de cumparare, producție Ordine, Ordinul de cumparare, Primirea de cumparare, Factura Vanzare, comandă de vânzări, Stock intrare, pontajul"
Average Age,Vârsta medie
Average Commission Rate,Rata medie a Comisiei
Average Discount,Reducere medie
Awesome Products,Produse Awesome
Awesome Services,Servicii de Awesome
BOM Detail No,BOM Detaliu Nu
BOM Explosion Item,BOM explozie Postul
BOM Item,BOM Articol
BOM No,BOM Nu
BOM No. for a Finished Good Item,BOM Nu pentru un bun element finit
BOM Operation,BOM Operațiunea
BOM Operations,BOM Operațiuni
BOM Replace Tool,BOM Înlocuiți Tool
BOM number is required for manufactured Item {0} in row {1},Este necesară număr BOM pentru articol fabricat {0} în rândul {1}
BOM number not allowed for non-manufactured Item {0} in row {1},Număr BOM nu este permis pentru postul non-fabricat {0} în rândul {1}
BOM recursion: {0} cannot be parent or child of {2},BOM recursivitate: {0} nu poate fi parinte sau copil din {2}
BOM replaced,BOM înlocuit
BOM {0} for Item {1} in row {2} is inactive or not submitted,BOM {0} pentru postul {1} în rândul {2} este inactiv sau nu a prezentat
BOM {0} is not active or not submitted,BOM {0} nu este activ sau nu a prezentat
BOM {0} is not submitted or inactive BOM for Item {1},BOM {0} nu este depusă sau inactiv BOM pentru postul {1}
Backup Manager,Backup Manager
Backup Right Now,Backup chiar acum
Backups will be uploaded to,Copiile de rezervă va fi încărcat la
Balance Qty,Echilibru Cantitate
Balance Sheet,Bilanțul
Balance Value,Echilibru Valoarea
Balance for Account {0} must always be {1},Bilant pentru Contul {0} trebuie să fie întotdeauna {1}
Balance must be,Echilibru trebuie să fie
"Balances of Accounts of type ""Bank"" or ""Cash""","Soldurile de conturi de tip ""Banca"" sau ""Cash"""
Bank,Banca
Bank / Cash Account,Bank / cont Cash
Bank A/C No.,Bank A / C Nr
Bank Account,Cont bancar
Bank Account No.,Cont bancar nr
Bank Accounts,Conturi bancare
Bank Clearance Summary,Clearance Bank Sumar
Bank Draft,Proiect de bancă
Bank Name,Numele bancii
Bank Overdraft Account,Descoperitul de cont bancar
Bank Reconciliation,Banca Reconciliere
Bank Reconciliation Detail,Banca Reconcilierea Detaliu
Bank Reconciliation Statement,Extras de cont de reconciliere
Bank Voucher,Bancă Voucher
Bank/Cash Balance,Bank / Cash Balance
Banking,Bancar
Barcode,Cod de bare
Barcode {0} already used in Item {1},Coduri de bare {0} deja folosit în articol {1}
Based On,Bazat pe
Basic,Baza
Basic Info,Informații de bază
Basic Information,Informații de bază
Basic Rate,Rata de bază
Basic Rate (Company Currency),Rata de bază (Compania de valuta)
Batch,Lot
Batch (lot) of an Item.,Lot (lot) de un articol.
Batch Finished Date,Lot terminat Data
Batch ID,ID-ul lotului
Batch No,Lot Nu
Batch Started Date,Lot început Data
Batch Time Logs for billing.,Lot de timp Bușteni pentru facturare.
Batch-Wise Balance History,Lot-înțelept Balanța Istorie
Batched for Billing,Dozat de facturare
Better Prospects,Perspective mai bune
Bill Date,Bill Data
Bill No,Bill Nu
Bill No {0} already booked in Purchase Invoice {1},Bill Nu {0} deja rezervat în cumparare Factura {1}
Bill of Material,Bill of Material
Bill of Material to be considered for manufacturing,Bill of Material să fie luate în considerare pentru producție
Bill of Materials (BOM),Factura de materiale (BOM)
Billable,Facturabile
Billed,Facturat
Billed Amount,Facturat Suma
Billed Amt,Facturate Amt
Billing,De facturare
Billing Address,Adresa de facturare
Billing Address Name,Adresa de facturare Numele
Billing Status,Starea de facturare
Bills raised by Suppliers.,Facturile ridicate de furnizori.
Bills raised to Customers.,Facturi ridicate pentru clienți.
Bin,Bin
Bio,Biografie
Biotechnology,Biotehnologie
Birthday,Ziua de naştere
Block Date,Bloc Data
Block Days,Bloc de zile
Block leave applications by department.,Blocați aplicații de concediu de către departament.
Blog Post,Blog Mesaj
Blog Subscriber,Blog Abonat
Blood Group,Grupa de sânge
Both Warehouse must belong to same Company,Ambele Warehouse trebuie să aparțină aceleiași companii
Box,Cutie
Branch,Ramură
Brand,Marca:
Brand Name,Nume de brand
Brand master.,Maestru de brand.
Brands,Brand-uri
Breakdown,Avarie
Broadcasting,Radiodifuzare
Brokerage,De brokeraj
Budget,Bugetul
Budget Allocated,Bugetul alocat
Budget Detail,Buget Detaliu
Budget Details,Buget Detalii
Budget Distribution,Buget Distribuție
Budget Distribution Detail,Buget Distribution Detaliu
Budget Distribution Details,Detalii buget de distribuție
Budget Variance Report,Buget Variance Raportul
Budget cannot be set for Group Cost Centers,Bugetul nu poate fi setat pentru centre de cost Group
Build Report,Construi Raport
Bundle items at time of sale.,Bundle elemente la momentul de vânzare.
Business Development Manager,Business Development Manager de
Buying,Cumpărare
Buying & Selling,De cumparare si vânzare
Buying Amount,Suma de cumpărare
Buying Settings,Cumpararea Setări
"Buying must be checked, if Applicable For is selected as {0}","De cumpărare trebuie să fie verificate, dacă este cazul Pentru este selectat ca {0}"
C-Form,C-Form
C-Form Applicable,C-forma aplicabila
C-Form Invoice Detail,C-Form Factura Detalii
C-Form No,C-Form No
C-Form records,Înregistrări C-Form
CENVAT Capital Goods,CENVAT bunurilor de capital
CENVAT Edu Cess,CENVAT Edu Cess
CENVAT SHE Cess,CENVAT SHE Cess
CENVAT Service Tax,CENVAT Serviciul Fiscal
CENVAT Service Tax Cess 1,CENVAT Serviciul Fiscal de Cess 1
CENVAT Service Tax Cess 2,CENVAT Serviciul Fiscal de Cess 2
Calculate Based On,Calculează pe baza
Calculate Total Score,Calcula Scor total
Calendar Events,Calendar Evenimente
Call,Apelaţi
Calls,Apeluri
Campaign,Campanie
Campaign Name,Numele campaniei
Campaign Name is required,Este necesară Numele campaniei
Campaign Naming By,Naming campanie de
Campaign-.####,Campanie.# # # #
Can be approved by {0},Pot fi aprobate de către {0}
"Can not filter based on Account, if grouped by Account","Nu se poate filtra pe baza de cont, în cazul în care grupate pe cont"
"Can not filter based on Voucher No, if grouped by Voucher","Nu se poate filtra pe baza voucher Nu, dacă grupate de Voucher"
Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Se poate referi rând numai dacă tipul de taxa este ""La rândul precedent Suma"" sau ""Previous rând Total"""
Cancel Material Visit {0} before cancelling this Customer Issue,Anula Material Vizitează {0} înainte de a anula această problemă client
Cancel Material Visits {0} before cancelling this Maintenance Visit,Anula Vizite materiale {0} înainte de a anula această întreținere Viziteaza
Cancelled,Anulat
Cancelling this Stock Reconciliation will nullify its effect.,Anularea acest Stock reconciliere va anula efectul.
Cannot Cancel Opportunity as Quotation Exists,Nu se poate anula oportunitate așa cum există ofertă
Cannot approve leave as you are not authorized to approve leaves on Block Dates,Nu poate aproba concediu ca nu sunt autorizate să aprobe frunze pe Block Date
Cannot cancel because Employee {0} is already approved for {1},Nu pot anula din cauza angajaților {0} este deja aprobat pentru {1}
Cannot cancel because submitted Stock Entry {0} exists,"Nu pot anula, deoarece a prezentat Bursa de intrare {0} există"
Cannot carry forward {0},Nu se poate duce mai departe {0}
Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Nu se poate schimba anul fiscal Data de începere și se termină anul fiscal Data odată ce anul fiscal este salvată.
"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Nu se poate schimba implicit moneda companiei, deoarece există tranzacții existente. Tranzacțiile trebuie să fie anulate de a schimba moneda implicit."
Cannot convert Cost Center to ledger as it has child nodes,"Nu se poate converti de cost Centrul de registru, deoarece are noduri copil"
Cannot covert to Group because Master Type or Account Type is selected.,Nu se poate sub acoperire să Group deoarece este selectat de Master de tip sau de tip de cont.
Cannot deactive or cancle BOM as it is linked with other BOMs,"Nu pot DEACTIVE sau cancle BOM, deoarece este legat cu alte extraselor"
"Cannot declare as lost, because Quotation has been made.","Nu poate declara ca a pierdut, pentru că ofertă a fost făcută."
Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Nu se poate deduce când categorie este de ""evaluare"" sau ""de evaluare și total"""
"Cannot delete Serial No {0} in stock. First remove from stock, then delete.","Nu se poate șterge Nu Serial {0} în stoc. Mai întâi se scoate din stoc, apoi ștergeți."
"Cannot directly set amount. For 'Actual' charge type, use the rate field","Nu se poate seta direct sumă. De tip taxă ""real"", utilizați câmpul rata"
"Cannot overbill for Item {0} in row {0} more than {1}. To allow overbilling, please set in Stock Settings","Nu pot overbill pentru postul {0} în rândul {0} mai mult de {1}. Pentru a permite supraîncărcată, vă rugăm să setați în stoc Setări"
Cannot produce more Item {0} than Sales Order quantity {1},Nu poate produce mai mult Postul {0} decât cantitatea de vânzări Ordine {1}
Cannot refer row number greater than or equal to current row number for this Charge type,Nu se poate referi număr de rând mai mare sau egal cu numărul actual rând pentru acest tip de încărcare
Cannot return more than {0} for Item {1},Nu se poate reveni mai mult de {0} pentru postul {1}
Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Nu se poate selecta tipul de încărcare ca ""La rândul precedent Suma"" sau ""On anterioară rândul Total"" pentru primul rând"
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,"Nu se poate selecta tipul de încărcare ca ""La rândul precedent Suma"" sau ""On anterioară rândul Total"" pentru evaluare. Puteți selecta opțiunea ""Total"" pentru suma de rând anterior sau totală rând anterior"
Cannot set as Lost as Sales Order is made.,Nu se poate seta la fel de pierdut ca se face comandă de vânzări.
Cannot set authorization on basis of Discount for {0},Nu se poate seta de autorizare pe baza de Discount pentru {0}
Capacity,Capacitate
Capacity Units,Unități de capacitate
Capital Account,Contul de capital
Capital Equipments,Echipamente de capital
Carry Forward,Reporta
Carry Forwarded Leaves,Carry Frunze transmis
Case No(s) already in use. Try from Case No {0},Cazul (e) deja în uz. Încercați din cauza nr {0}
Case No. cannot be 0,"Caz Nu, nu poate fi 0"
Cash,Numerar
Cash In Hand,Bani în mână
Cash Voucher,Cash Voucher
Cash or Bank Account is mandatory for making payment entry,Numerar sau cont bancar este obligatorie pentru a face intrarea plată
Cash/Bank Account,Contul Cash / Banca
Casual Leave,Casual concediu
Cell Number,Numărul de celule
Change UOM for an Item.,Schimba UOM pentru un element.
Change the starting / current sequence number of an existing series.,Schimbați pornire / numărul curent de ordine dintr-o serie existent.
Channel Partner,Channel Partner
Charge of type 'Actual' in row {0} cannot be included in Item Rate,"Responsabilă de tip ""real"" în rândul {0} nu poate fi inclus în postul Rate"
Chargeable,Chargeable
Charity and Donations,Caritate și donații
Chart Name,Diagramă Denumire
Chart of Accounts,Planul de conturi
Chart of Cost Centers,Grafic de centre de cost
Check how the newsletter looks in an email by sending it to your email.,Verifica modul în newsletter-ul arată într-un e-mail prin trimiterea acesteia la adresa dvs. de email.
"Check if recurring invoice, uncheck to stop recurring or put proper End Date","Verificați dacă recurente factura, debifați pentru a opri recurente sau pune buna Data de încheiere"
"Check if you need automatic recurring invoices. After submitting any sales invoice, Recurring section will be visible.","Verificați dacă aveți nevoie de facturi automate recurente. După depunerea orice factură de vânzare, sectiunea recurente vor fi vizibile."
Check if you want to send salary slip in mail to each employee while submitting salary slip,Verificați dacă doriți să trimiteți fișa de salariu în e-mail pentru fiecare angajat în timp ce depunerea alunecare salariu
Check this if you want to force the user to select a series before saving. There will be no default if you check this.,"Verifica acest lucru dacă doriți pentru a forța utilizatorului să selecteze o serie înainte de a salva. Nu va fi nici implicit, dacă tu a verifica acest lucru."
Check this if you want to show in website,Verifica acest lucru dacă doriți să arate în site-ul
Check this to disallow fractions. (for Nos),Verifica acest lucru pentru a nu permite fracțiuni. (Pentru Nos)
Check this to pull emails from your mailbox,Verifica acest lucru pentru a trage e-mailuri de la căsuța poștală
Check to activate,Verificați pentru a activa
Check to make Shipping Address,Verificați pentru a vă adresa Shipping
Check to make primary address,Verificați pentru a vă adresa primar
Chemical,Chimic
Cheque,Cheque
Cheque Date,Cec Data
Cheque Number,Numărul Cec
Child account exists for this account. You can not delete this account.,Contul copil există pentru acest cont. Nu puteți șterge acest cont.
City,Oraș
City/Town,Orasul / Localitatea
Claim Amount,Suma cerere
Claims for company expense.,Cererile pentru cheltuieli companie.
Class / Percentage,Clasă / Procentul
Classic,Conditionarea clasica apare atunci cand unui stimul i se raspunde printr-un reflex natural
Clear Table,Clar masă
Clearance Date,Clearance Data
Clearance Date not mentioned,Clearance Data nu sunt menționate
Clearance date cannot be before check date in row {0},Data de clearance-ul nu poate fi înainte de data de check-in rândul {0}
Click on 'Make Sales Invoice' button to create a new Sales Invoice.,"Faceți clic pe butonul ""face Factura Vanzare"" pentru a crea o nouă factură de vânzare."
Click on a link to get options to expand get options ,
Client,Client
Close Balance Sheet and book Profit or Loss.,Aproape Bilanțul și carte profit sau pierdere.
Closed,Inchisa
Closing (Cr),De închidere (Cr)
Closing (Dr),De închidere (Dr)
Closing Account Head,Închiderea contului cap
Closing Account {0} must be of type 'Liability',"Contul {0} de închidere trebuie să fie de tip ""Răspunderea"""
Closing Date,Data de închidere
Closing Fiscal Year,Închiderea Anul fiscal
Closing Qty,Cantitate de închidere
Closing Value,Valoare de închidere
CoA Help,CoA Ajutor
Code,Cod
Cold Calling,De asteptare la rece
Color,Culorarea
Column Break,Coloana Break
Comma separated list of email addresses,Virgulă listă de adrese de e-mail separat
Comment,Comentariu
Comments,Comentarii
Commercial,Comercial
Commission,Comision
Commission Rate,Rata de comisie
Commission Rate (%),Rata de comision (%)
Commission on Sales,Comision din vânzări
Commission rate cannot be greater than 100,Rata de comision nu poate fi mai mare de 100
Communication,Comunicare
Communication HTML,Comunicare HTML
Communication History,Istoria comunicare
Communication log.,Log comunicare.
Communications,Interfata
Company,Firma
Company (not Customer or Supplier) master.,Compania (nu client sau furnizor) de master.
Company Abbreviation,Abreviere de companie
Company Details,Detalii companie
Company Email,Compania de e-mail
"Company Email ID not found, hence mail not sent","Compania ID-ul de e-mail nu a fost găsit, prin urmare, nu e-mail trimis"
Company Info,Informatii companie
Company Name,Nume firma acasa
Company Settings,Setări Company
Company is missing in warehouses {0},Compania lipsește în depozite {0}
Company is required,Este necesară Company
Company registration numbers for your reference. Example: VAT Registration Numbers etc.,"Numerele de înregistrare companie pentru referință. Numerele de înregistrare TVA, etc: de exemplu,"
Company registration numbers for your reference. Tax numbers etc.,Numerele de înregistrare companie pentru referință. Numerele fiscale etc
"Company, Month and Fiscal Year is mandatory","Compania, Luna și Anul fiscal este obligatorie"
Compensatory Off,Compensatorii Off
Complete,Finalizare
Complete Setup,Setup Complete
Completed,Finalizat
Completed Production Orders,Comenzile de producție terminate
Completed Qty,Completat Cantitate
Completion Date,Finalizarea Data
Completion Status,Starea de finalizare
Computer,Calculator
Computers,Calculatoare
Confirmation Date,Confirmarea Data
Confirmed orders from Customers.,Comenzile confirmate de la clienți.
Consider Tax or Charge for,Luați în considerare fiscală sau de încărcare pentru
Considered as Opening Balance,Considerat ca Sold
Considered as an Opening Balance,Considerat ca un echilibru de deschidere
Consultant,Consultant
Consulting,Consili
Consumable,Consumabil
Consumable Cost,Cost Consumabile
Consumable cost per hour,Costul consumabil pe oră
Consumed Qty,Consumate Cantitate
Consumer Products,Produse de larg consum
Contact,Persoană
Contact Control,Contact de control
Contact Desc,Contact Descărca
Contact Details,Detalii de contact
Contact Email,Contact Email
Contact HTML,Contact HTML
Contact Info,Informaţii de contact
Contact Mobile No,Contact Mobile Nu
Contact Name,Nume contact
Contact No.,Contact Nu.
Contact Person,Persoană de contact
Contact Type,Contact Tip
Contact master.,Contact maestru.
Contacts,Contacte
Content,Continut
Content Type,Tip de conținut
Contra Voucher,Contra Voucher
Contract,Contractarea
Contract End Date,Contract Data de încheiere
Contract End Date must be greater than Date of Joining,Contract Data de sfârșit trebuie să fie mai mare decât Data aderării
Contribution (%),Contribuția (%)
Contribution to Net Total,Contribuția la net total
Conversion Factor,Factor de conversie
Conversion Factor is required,Este necesară Factorul de conversie
Conversion factor cannot be in fractions,Factor de conversie nu pot fi în fracțiuni
Conversion factor for default Unit of Measure must be 1 in row {0},Factor de conversie pentru Unitatea implicit de măsură trebuie să fie de 1 la rând {0}
Conversion rate cannot be 0 or 1,Rata de conversie nu poate fi 0 sau 1
Convert into Recurring Invoice,Conversia în factura recurente
Convert to Group,Conversia de grup
Convert to Ledger,Conversia la Ledger
Converted,Convertit
Copy From Item Group,Copiere din Grupa de articole
Cosmetics,Cosmetică
Cost Center,Cost Center
Cost Center Details,Cost Center Detalii
Cost Center Name,Cost Numele Center
Cost Center is required for 'Profit and Loss' account {0},"Cost Center este necesară pentru contul ""Profit și pierdere"" {0}"
Cost Center is required in row {0} in Taxes table for type {1},Cost Center este necesară în rândul {0} în tabelul Taxele de tip {1}
Cost Center with existing transactions can not be converted to group,Centrul de cost cu tranzacțiile existente nu pot fi transformate în grup
Cost Center with existing transactions can not be converted to ledger,Centrul de cost cu tranzacții existente nu pot fi convertite în registrul
Cost Center {0} does not belong to Company {1},Cost Centrul {0} nu aparține companiei {1}
Cost of Goods Sold,Costul bunurilor vândute
Costing,Costing
Country,Ţară
Country Name,Nume țară
Country wise default Address Templates,Șabloanele țară înțelept adresa implicită
"Country, Timezone and Currency","Țară, Timezone și valutar"
Create Bank Voucher for the total salary paid for the above selected criteria,Crea Bank Voucher pentru salariul totală plătită pentru criteriile selectate de mai sus
Create Customer,Creare client
Create Material Requests,Cererile crea materiale
Create New,Crearea de noi
Create Opportunity,Creare Oportunitate
Create Production Orders,Creare comenzi de producție
Create Quotation,Creare ofertă
Create Receiver List,Crea Receiver Lista
Create Salary Slip,Crea Salariul Slip
Create Stock Ledger Entries when you submit a Sales Invoice,Crea Stock Ledger intrările atunci când depune o factură de vânzare
"Create and manage daily, weekly and monthly email digests.","Crearea și gestionarea de e-mail rezumate zilnice, săptămânale și lunare."
Create rules to restrict transactions based on values.,Creați reguli pentru a restricționa tranzacțiile bazate pe valori.
Created By,Creat de
Creates salary slip for above mentioned criteria.,Creează alunecare salariu pentru criteriile de mai sus.
Creation Date,Data creării
Creation Document No,Creare de documente Nu
Creation Document Type,Tip de document creație
Creation Time,Timp de creație
Credentials,Scrisori de acreditare
Credit,credit
Credit Amt,Credit Amt
Credit Card,Card de credit
Credit Card Voucher,Card de credit Voucher
Credit Controller,Controler de credit
Credit Days,Zile de credit
Credit Limit,Limita de credit
Credit Note,Nota de credit
Credit To,De credit a
Currency,Monedă
Currency Exchange,Schimb valutar
Currency Name,Numele valută
Currency Settings,Setări valutare
Currency and Price List,Valută și lista de prețuri
Currency exchange rate master.,Maestru cursului de schimb valutar.
Current Address,Adresa curent
Current Address Is,Adresa actuală este
Current Assets,Active curente
Current BOM,BOM curent
Current BOM and New BOM can not be same,BOM BOM curent și noi nu poate fi același
Current Fiscal Year,Anul fiscal curent
Current Liabilities,Datorii curente
Current Stock,Stock curent
Current Stock UOM,Stock curent UOM
Current Value,Valoare curent
Custom,Particularizat
Custom Autoreply Message,Personalizat Răspuns automat Mesaj
Custom Message,Mesaj personalizat
Customer,Client
Customer (Receivable) Account,Client (de încasat) Cont
Customer / Item Name,Client / Denumire
Customer / Lead Address,Client / plumb Adresa
Customer / Lead Name,Client / Nume de plumb
Customer > Customer Group > Territory,Client> Client Group> Teritoriul
Customer Account Head,Cont client cap
Customer Acquisition and Loyalty,Achiziționarea client și Loialitate
Customer Address,Client Adresa
Customer Addresses And Contacts,Adrese de clienți și Contacte
Customer Addresses and Contacts,Adrese clienților și Contacte
Customer Code,Cod client
Customer Codes,Coduri de client
Customer Details,Detalii client
Customer Feedback,Customer Feedback
Customer Group,Grup de clienti
Customer Group / Customer,Grupa client / client
Customer Group Name,Nume client Group
Customer Intro,Intro client
Customer Issue,Client Issue
Customer Issue against Serial No.,Problema client împotriva Serial No.
Customer Name,Nume client
Customer Naming By,Naming client de
Customer Service,Serviciul Clienți
Customer database.,Bazei de clienti.
Customer is required,Clientul este necesară
Customer master.,Maestru client.
Customer required for 'Customerwise Discount',"Client necesar pentru ""Customerwise Discount"""
Customer {0} does not belong to project {1},Client {0} nu face parte din proiect {1}
Customer {0} does not exist,Client {0} nu există
Customer's Item Code,Clientului Articol Cod
Customer's Purchase Order Date,Clientului comandă de aprovizionare Data
Customer's Purchase Order No,Clientului Comandă Nu
Customer's Purchase Order Number,Clientului Comandă Numărul
Customer's Vendor,Vendor clientului
Customers Not Buying Since Long Time,Clienții nu Cumpararea de mult timp Timpul
Customerwise Discount,Customerwise Reducere
Customize,Personalizarea
Customize the Notification,Personaliza Notificare
Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,"Particulariza textul introductiv, care merge ca o parte din acel email. Fiecare tranzacție are un text introductiv separat."
DN Detail,DN Detaliu
Daily,Zilnic
Daily Time Log Summary,Zilnic Timp Log Rezumat
Database Folder ID,Baza de date Folder ID
Database of potential customers.,Baza de date de clienți potențiali.
Date,Dată
Date Format,Format dată
Date Of Retirement,Data pensionării
Date Of Retirement must be greater than Date of Joining,Data de pensionare trebuie să fie mai mare decât Data aderării
Date is repeated,Data se repetă
Date of Birth,Data nașterii
Date of Issue,Data eliberării
Date of Joining,Data aderării
Date of Joining must be greater than Date of Birth,Data aderării trebuie să fie mai mare decât Data nașterii
Date on which lorry started from supplier warehouse,Data la care a început camion din depozitul furnizorul
Date on which lorry started from your warehouse,Data la care camion a pornit de la depozit
Dates,Perioada
Days Since Last Order,De zile de la ultima comandă
Days for which Holidays are blocked for this department.,De zile pentru care Sărbătorile sunt blocate pentru acest departament.
Dealer,Comerciant
Debit,Debitarea
Debit Amt,Amt debit
Debit Note,Nota de debit
Debit To,Pentru debit
Debit and Credit not equal for this voucher. Difference is {0}.,De debit și de credit nu este egal pentru acest voucher. Diferența este {0}.
Deduct,Deduce
Deduction,Deducere
Deduction Type,Deducerea Tip
Deduction1,Deduction1
Deductions,Deduceri
Default,Implicit
Default Account,Contul implicit
Default Address Template cannot be deleted,Format implicit Adresa nu poate fi șters
Default Amount,Implicit Suma
Default BOM,Implicit BOM
Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,"Default cont bancar / numerar vor fi actualizate în mod automat în POS Factura, atunci când acest mod este selectat."
Default Bank Account,Implicit cont bancar
Default Buying Cost Center,Implicit de cumparare cost Center
Default Buying Price List,Implicit de cumparare Lista de prețuri
Default Cash Account,Contul Cash implicit
Default Company,Implicit de companie
Default Currency,Monedă implicită
Default Customer Group,Implicit Client Group
Default Expense Account,Cont implicit de cheltuieli
Default Income Account,Contul implicit venituri
Default Item Group,Implicit Element Group
Default Price List,Implicit Lista de prețuri
Default Purchase Account in which cost of the item will be debited.,Implicit cont cumparare în care costul de elementul va fi debitat.
Default Selling Cost Center,Implicit de vânzare Cost Center
Default Settings,Setări implicite
Default Source Warehouse,Implicit Sursa Warehouse
Default Stock UOM,Implicit Stock UOM
Default Supplier,Implicit Furnizor
Default Supplier Type,Implicit Furnizor Tip
Default Target Warehouse,Implicit țintă Warehouse
Default Territory,Implicit Teritoriul
Default Unit of Measure,Unitatea de măsură prestabilită
"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.","Unitatea implicit de măsură nu poate fi modificat direct deoarece le-ați făcut deja unele tranzacții (s) cu un alt UOM. Pentru a schimba implicit UOM, folosiți ""UOM Înlocuiți Utility"" instrument în modul stoc."
Default Valuation Method,Metoda implicită de evaluare
Default Warehouse,Implicit Warehouse
Default Warehouse is mandatory for stock Item.,Implicit Warehouse este obligatorie pentru stoc articol.
Default settings for accounting transactions.,Setările implicite pentru tranzacțiile de contabilitate.
Default settings for buying transactions.,Setările implicite pentru tranzacțiilor de cumpărare.
Default settings for selling transactions.,Setările implicite pentru tranzacțiile de vânzare.
Default settings for stock transactions.,Setările implicite pentru tranzacțiile bursiere.
Defense,Apărare
"Define Budget for this Cost Center. To set budget action, see <a href=""#!List/Company"">Company Master</a>","Definirea Bugetul pentru acest centru de cost. Pentru a seta o acțiune buget, consultați <a href = ""#!Lista / Compania ""> Compania Maestrul </ a>"
Del,Del
Delete,Șterge
Delete {0} {1}?,Șterge {0} {1}?
Delivered,Livrat
Delivered Items To Be Billed,Produsele livrate Pentru a fi facturat
Delivered Qty,Livrate Cantitate
Delivered Serial No {0} cannot be deleted,Livrate de ordine {0} nu poate fi ștearsă
Delivery Date,Data de livrare
Delivery Details,Detalii livrare
Delivery Document No,Livrare de documente Nu
Delivery Document Type,Tip de livrare document
Delivery Note,Livrare Nota
Delivery Note Item,Livrare Nota Articol
Delivery Note Items,Livrare Nota Articole
Delivery Note Message,Livrare Nota Mesaj
Delivery Note No,Livrare Nota Nu
Delivery Note Required,Nota de livrare Necesar
Delivery Note Trends,Livrare Nota Tendințe
Delivery Note {0} is not submitted,Livrare Nota {0} nu este prezentat
Delivery Note {0} must not be submitted,Livrare Nota {0} nu trebuie să fie prezentate
Delivery Notes {0} must be cancelled before cancelling this Sales Order,Livrare Note {0} trebuie anulată înainte de a anula această comandă de vânzări
Delivery Status,Starea de livrare
Delivery Time,Timp de livrare
Delivery To,De livrare a
Department,Departament
Department Stores,Magazine Universale
Depends on LWP,Depinde LWP
Depreciation,Depreciere
Description,Descriere
Description HTML,Descrierea HTML
Designation,Denumire
Designer,Proiectant
Detailed Breakup of the totals,Despărțiri detaliată a totalurilor
Details,Detalii
Difference (Dr - Cr),Diferența (Dr - Cr)
Difference Account,Diferența de cont
"Difference Account must be a 'Liability' type account, since this Stock Reconciliation is an Opening Entry","Diferență de cont trebuie să fie un cont de tip ""Răspunderea"", deoarece acest Stock Reconcilierea este o intrare de deschidere"
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.,Diferit UOM pentru un produs va duce la incorect (Total) Net valoare greutate. Asigurați-vă că greutatea netă a fiecărui element este în același UOM.
Direct Expenses,Cheltuieli directe
Direct Income,Venituri directe
Disable,Dezactivați
Disable Rounded Total,Dezactivați rotunjite total
Disabled,Invalid
Discount  %,Discount%
Discount %,Discount%
Discount (%),Discount (%)
Discount Amount,Discount Suma
"Discount Fields will be available in Purchase Order, Purchase Receipt, Purchase Invoice","Discount Fields va fi disponibil în cumparare Ordine, Primirea de cumparare, cumparare factura"
Discount Percentage,Procentul de reducere
Discount Percentage can be applied either against a Price List or for all Price List.,Procentul de reducere se poate aplica fie pe o listă de prețuri sau pentru toate lista de prețuri.
Discount must be less than 100,Reducere trebuie să fie mai mică de 100
Discount(%),Discount (%)
Dispatch,Expedierea
Display all the individual items delivered with the main items,Afișa toate elementele individuale livrate cu elementele principale
Distribute transport overhead across items.,Distribui aeriene de transport pe obiecte.
Distribution,Distribuire
Distribution Id,Id-ul de distribuție
Distribution Name,Distribuție Nume
Distributor,Distribuitor
Divorced,Divorțat
Do Not Contact,Nu de contact
Do not show any symbol like $ etc next to currencies.,Nu prezintă nici un simbol de genul $ etc alături de valute.
Do really want to unstop production order: ,
Do you really want to STOP ,
Do you really want to STOP this Material Request?,Chiar vrei pentru a opri această cerere Material?
Do you really want to Submit all Salary Slip for month {0} and year {1},Chiar vrei să prezinte toate Slip Salariul pentru luna {0} și {1 an}
Do you really want to UNSTOP ,
Do you really want to UNSTOP this Material Request?,Chiar vrei să unstop această cerere Material?
Do you really want to stop production order: ,
Doc Name,Doc Nume
Doc Type,Doc Tip
Document Description,Document Descriere
Document Type,Tip de document
Documents,Documente
Domain,Domeniu
Don't send Employee Birthday Reminders,Nu trimiteți Angajat Data nasterii Memento
Download Materials Required,Descărcați Materiale necesare
Download Reconcilation Data,Descărcați reconcilierii datelor
Download Template,Descărcați Format
Download a report containing all raw materials with their latest inventory status,Descărca un raport care conține toate materiile prime cu statutul lor ultimul inventar
"Download the Template, fill appropriate data and attach the modified file.","Descărcați șablonul, umple de date corespunzătoare și atașați fișierul modificat."
"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","Descărcați șablonul, umple de date corespunzătoare și atașați fișierul modificat.
 TOATE DATELE ȘI combinație angajat în perioada selectată va veni în șablon, cu înregistrări de prezență existente"
Draft,Ciornă
Dropbox,Dropbox
Dropbox Access Allowed,Dropbox de acces permise
Dropbox Access Key,Dropbox Access Key
Dropbox Access Secret,Dropbox Access Secret
Due Date,Data scadenței
Due Date cannot be after {0},Datorită Data nu poate fi după {0}
Due Date cannot be before Posting Date,Datorită Data nu poate fi înainte de a posta Data
Duplicate Entry. Please check Authorization Rule {0},Duplicat de intrare. Vă rugăm să verificați de autorizare Regula {0}
Duplicate Serial No entered for Item {0},Duplicat de ordine introduse pentru postul {0}
Duplicate entry,Duplicat de intrare
Duplicate row {0} with same {1},Duplicate rând {0} cu aceeași {1}
Duties and Taxes,Impozite și taxe
ERPNext Setup,ERPNext Setup
Earliest,Mai devreme
Earnest Money,Bani Earnest
Earning,Câștigul salarial
Earning & Deduction,Câștigul salarial & Deducerea
Earning Type,Câștigul salarial Tip
Earning1,Earning1
Edit,Editează
Edu. Cess on Excise,Edu. Cess pe accize
Edu. Cess on Service Tax,Edu. Cess la Serviciul Fiscal
Edu. Cess on TDS,Edu. Cess pe TDS
Education,Educație
Educational Qualification,Calificare de învățământ
Educational Qualification Details,De învățământ de calificare Detalii
Eg. smsgateway.com/api/send_sms.cgi,De exemplu. smsgateway.com / API / send_sms.cgi
Either debit or credit amount is required for {0},"Este necesar, fie de debit sau de credit pentru suma de {0}"
Either target qty or target amount is mandatory,Fie cantitate țintă sau valoarea țintă este obligatorie
Either target qty or target amount is mandatory.,Fie cantitate țintă sau valoarea țintă este obligatorie.
Electrical,Din punct de vedere electric
Electricity Cost,Costul energiei electrice
Electricity cost per hour,Costul de energie electrică pe oră
Electronics,Electronică
Email,E-mail
Email Digest,Email Digest
Email Digest Settings,E-mail Settings Digest
Email Digest: ,
Email Id,E-mail Id-ul
"Email Id where a job applicant will email e.g. ""jobs@example.com""","E-mail Id-ul în cazul în care un solicitant de loc de muncă va trimite un email de exemplu ""jobs@example.com"""
Email Notifications,Notificări e-mail
Email Sent?,E-mail trimis?
"Email id must be unique, already exists for {0}","E-mail id trebuie să fie unic, există deja pentru {0}"
Email ids separated by commas.,ID-uri de e-mail separate prin virgule.
"Email settings to extract Leads from sales email id e.g. ""sales@example.com""","Setările de e-mail pentru a extrage de afaceri din vânzările de e-mail id-ul de exemplu, ""sales@example.com"""
Emergency Contact,De urgență Contact
Emergency Contact Details,Detalii de contact de urgență
Emergency Phone,Telefon de urgență
Employee,Angajat
Employee Birthday,Angajat de naștere
Employee Details,Detalii angajaților
Employee Education,Angajat Educație
Employee External Work History,Angajat Istoricul lucrului extern
Employee Information,Informații angajat
Employee Internal Work History,Angajat Istoricul lucrului intern
Employee Internal Work Historys,Angajat intern de lucru Historys
Employee Leave Approver,Angajat concediu aprobator
Employee Leave Balance,Angajat concediu Balance
Employee Name,Nume angajat
Employee Number,Numar angajat
Employee Records to be created by,Angajaților Records a fi create prin
Employee Settings,Setări angajaților
Employee Type,Tipul angajatului
"Employee designation (e.g. CEO, Director etc.).","Desemnarea angajat (de exemplu, CEO, director, etc)."
Employee master.,Maestru angajat.
Employee record is created using selected field. ,
Employee records.,Înregistrările angajaților.
Employee relieved on {0} must be set as 'Left',"Angajat eliberat pe {0} trebuie să fie setat ca ""stânga"""
Employee {0} has already applied for {1} between {2} and {3},Angajat {0} a aplicat deja pentru {1} între {2} și {3}
Employee {0} is not active or does not exist,Angajat {0} nu este activ sau nu există
Employee {0} was on leave on {1}. Cannot mark attendance.,Angajat {0} a fost în concediu pe {1}. Nu se poate marca prezență.
Employees Email Id,Angajați mail Id-ul
Employment Details,Detalii ocuparea forței de muncă
Employment Type,Tipul de angajare
Enable / disable currencies.,Activarea / dezactivarea valute.
Enabled,Activat
Encashment Date,Data încasare
End Date,Data de încheiere
End Date can not be less than Start Date,Data de încheiere nu poate fi mai mic de Data de începere
End date of current invoice's period,Data de încheiere a perioadei facturii curente
End of Life,End of Life
Energy,Energie.
Engineer,Proiectarea
Enter Verification Code,Introduceti codul de verificare
Enter campaign name if the source of lead is campaign.,Introduceți numele campaniei în cazul în care sursa de plumb este de campanie.
Enter department to which this Contact belongs,Introduceti departamentul din care face parte acest contact
Enter designation of this Contact,Introduceți desemnarea acestui Contact
"Enter email id separated by commas, invoice will be mailed automatically on particular date","Introduceți ID-ul de e-mail separate prin virgule, factura va fi trimis prin poștă în mod automat la anumită dată"
Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,Introduce elemente și cantitate planificată pentru care doriți să ridice comenzi de producție sau descărcare materii prime pentru analiză.
Enter name of campaign if source of enquiry is campaign,"Introduceți numele de campanie, dacă sursa de anchetă este de campanie"
"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)","Introduceți parametrii url statice aici (de exemplu, expeditor = ERPNext, numele de utilizator = ERPNext, parola = 1,234, etc)"
Enter the company name under which Account Head will be created for this Supplier,Introduceți numele companiei sub care Account Director va fi creat pentru această Furnizor
Enter url parameter for message,Introduceți parametru url pentru mesaj
Enter url parameter for receiver nos,Introduceți parametru url pentru receptor nos
Entertainment & Leisure,Entertainment & Leisure
Entertainment Expenses,Cheltuieli de divertisment
Entries,Intrări
Entries against ,
Entries are not allowed against this Fiscal Year if the year is closed.,"Lucrările nu sunt permise în acest an fiscal, dacă anul este închis."
Equity,Echitate
Error: {0} > {1},Eroare: {0}> {1}
Estimated Material Cost,Costul estimat Material
"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Chiar dacă există mai multe reguli de stabilire a prețurilor, cu cea mai mare prioritate, se aplică apoi următoarele priorități interne:"
Everyone can read,Oricine poate citi
"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.",". Exemplu: ABCD # # # # # 
 În cazul în care seria este setat și nu de serie nu este menționat în tranzacții, numărul de atunci automat de serie va fi creat pe baza acestei serii. Dacă vrei mereu să menționeze în mod explicit de serie nr pentru acest articol. părăsi acest gol."
Exchange Rate,Rata de schimb
Excise Duty 10,Accize 10
Excise Duty 14,Accize 14
Excise Duty 4,Accize 4
Excise Duty 8,Accize 8
Excise Duty @ 10,Accize @ 10
Excise Duty @ 14,Accize @ 14
Excise Duty @ 4,Accize @ 4
Excise Duty @ 8,Accize @ 8
Excise Duty Edu Cess 2,Accizele Edu Cess 2
Excise Duty SHE Cess 1,Accizele SHE Cess 1
Excise Page Number,Numărul de accize Page
Excise Voucher,Accize Voucher
Execution,Detalii de fabricaţie
Executive Search,Executive Search
Exemption Limit,Limita de scutire
Exhibition,Expoziție
Existing Customer,Client existent
Exit,Ieșire
Exit Interview Details,Detalii ieșire Interviu
Expected,Preconizează
Expected Completion Date can not be less than Project Start Date,Așteptat Finalizarea Data nu poate fi mai mică de proiect Data de începere
Expected Date cannot be before Material Request Date,Data așteptat nu poate fi înainte Material Cerere Data
Expected Delivery Date,Așteptat Data de livrare
Expected Delivery Date cannot be before Purchase Order Date,Așteptat Data de livrare nu poate fi înainte de Comandă Data
Expected Delivery Date cannot be before Sales Order Date,Așteptat Data de livrare nu poate fi înainte de comandă de vânzări Data
Expected End Date,Așteptat Data de încheiere
Expected Start Date,Data de începere așteptată
Expense,cheltuială
Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Cheltuială cont / Diferența ({0}) trebuie să fie un cont de ""profit sau pierdere"""
Expense Account,Decont
Expense Account is mandatory,Contul de cheltuieli este obligatorie
Expense Claim,Cheltuieli de revendicare
Expense Claim Approved,Cheltuieli de revendicare Aprobat
Expense Claim Approved Message,Mesajul Expense Cerere aprobată
Expense Claim Detail,Cheltuieli de revendicare Detaliu
Expense Claim Details,Detalii cheltuială revendicare
Expense Claim Rejected,Cheltuieli de revendicare Respins
Expense Claim Rejected Message,Mesajul Expense Cerere Respins
Expense Claim Type,Cheltuieli de revendicare Tip
Expense Claim has been approved.,Cheltuieli de revendicare a fost aprobat.
Expense Claim has been rejected.,Cheltuieli de revendicare a fost respinsă.
Expense Claim is pending approval. Only the Expense Approver can update status.,Cheltuieli de revendicare este în curs de aprobare. Doar aprobator cheltuieli pot actualiza status.
Expense Date,Cheltuială Data
Expense Details,Detalii de cheltuieli
Expense Head,Cheltuială cap
Expense account is mandatory for item {0},Cont de cheltuieli este obligatorie pentru element {0}
Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,"Cheltuială sau Diferența cont este obligatorie pentru postul {0}, deoarece impactul valoare totală de stoc"
Expenses,Cheltuieli
Expenses Booked,Cheltuieli rezervare
Expenses Included In Valuation,Cheltuieli incluse în evaluare
Expenses booked for the digest period,Cheltuieli rezervat pentru perioada Digest
Expiry Date,Data expirării
Exports,Exporturile
External,Extern
Extract Emails,Extrage poștă electronică
FCFS Rate,FCFS Rate
Failed: ,
Family Background,Context familie
Fax,Fax
Features Setup,Caracteristici de configurare
Feed,Hrănirea / Încărcarea / Alimentarea / Aprovizionarea / Furnizarea
Feed Type,Tip de alimentare
Feedback,Feedback
Female,Feminin
Fetch exploded BOM (including sub-assemblies),Fetch BOM a explodat (inclusiv subansamble)
"Field available in Delivery Note, Quotation, Sales Invoice, Sales Order","Câmp disponibil în nota de livrare, cotatie, Factura Vanzare, comandă de vânzări"
Files Folder ID,Files Folder ID
Fill the form and save it,Completați formularul și să-l salvați
Filter based on customer,Filtru bazat pe client
Filter based on item,Filtru conform punctului
Financial / accounting year.,An financiar / contabil.
Financial Analytics,Analytics financiare
Financial Services,Servicii Financiare
Financial Year End Date,Anul financiar Data de încheiere
Financial Year Start Date,Anul financiar Data începerii
Finished Goods,Produse finite
First Name,Prenume
First Responded On,Primul răspuns la
Fiscal Year,Exercițiu financiar
Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Data începerii anului fiscal și se termină anul fiscal la data sunt deja stabilite în anul fiscal {0}
Fiscal Year Start Date and Fiscal Year End Date cannot be more than a year apart.,Anul fiscal Data de începere și se termină anul fiscal Data nu poate fi mai mult de un an în afară.
Fiscal Year Start Date should not be greater than Fiscal Year End Date,Anul fiscal Data începerii nu trebuie să fie mai mare decât anul fiscal Data de încheiere
Fixed Asset,Activelor fixe
Fixed Assets,Mijloace Fixe
Follow via Email,Urmați prin e-mail
"Following table will show values if items are sub - contracted. These values will be fetched from the master of ""Bill of Materials"" of sub - contracted items.","Tabelul de mai jos va arata valori în cazul în care elementele sunt sub - contractate. Aceste valori vor fi preluat de la maestru de ""Bill of Materials"" de sub - contractate elemente."
Food,Alimente
"Food, Beverage & Tobacco","Produse alimentare, bauturi si tutun"
"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.","Pentru ""Vanzari BOM"" elemente, Warehouse, Serial No și lot nu vor fi luate în considerare de la masa ""Lista de ambalare"". Dacă Warehouse și lot nu sunt aceleași pentru toate elementele de ambalare pentru orice 'Sales BOM ""element, aceste valori pot fi introduse în tabelul Articol principal, valori vor fi copiate la masa"" Lista de ambalare ""."
For Company,Pentru companie
For Employee,Pentru Angajat
For Employee Name,Pentru numele angajatului
For Price List,Pentru lista de preturi
For Production,Pentru producție
For Reference Only.,Numai pentru referință.
For Sales Invoice,Pentru Factura Vanzare
For Server Side Print Formats,Pentru formatele Print Server Side
For Supplier,De Furnizor
For Warehouse,Pentru Warehouse
For Warehouse is required before Submit,Pentru este necesară Warehouse înainte Trimite
"For e.g. 2012, 2012-13","De exemplu, 2012, 2012-13"
For reference,De referință
For reference only.,Pentru numai referință.
"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Pentru comoditatea clienților, aceste coduri pot fi utilizate în formate de imprimare, cum ar fi Facturi și note de livrare"
Fraction,Fracțiune
Fraction Units,Unități Fraction
Freeze Stock Entries,Freeze stoc Entries
Freeze Stocks Older Than [Days],Congelatoare Stocurile mai vechi de [zile]
Freight and Forwarding Charges,Marfă și de expediere Taxe
Friday,Vineri
From,Din data
From Bill of Materials,De la Bill de materiale
From Company,De la firma
From Currency,Din valutar
From Currency and To Currency cannot be same,Din valutar și a valutar nu poate fi același
From Customer,De la client
From Customer Issue,De la client Issue
From Date,De la data
From Date cannot be greater than To Date,De la data nu poate fi mai mare decât la data
From Date must be before To Date,De la data trebuie să fie înainte de a Dată
From Date should be within the Fiscal Year. Assuming From Date = {0},De la data trebuie să fie în anul fiscal. Presupunând că la data = {0}
From Delivery Note,De la livrare Nota
From Employee,Din Angajat
From Lead,Din plumb
From Maintenance Schedule,Din Program de întreținere
From Material Request,Din Material Cerere
From Opportunity,De oportunitate
From Package No.,Din Pachetul Nu
From Purchase Order,De Comandă
From Purchase Receipt,Primirea de la cumparare
From Quotation,Din ofertă
From Sales Order,De comandă de vânzări
From Supplier Quotation,Furnizor de ofertă
From Time,From Time
From Value,Din valoare
From and To dates required,De la și la termenul dorit
From value must be less than to value in row {0},De valoare trebuie să fie mai mică de valoare în rândul {0}
Frozen,Înghețat
Frozen Accounts Modifier,Congelate Conturi modificator
Fulfilled,Îndeplinite
Full Name,Numele complet
Full-time,Full-time
Fully Billed,Complet Taxat
Fully Completed,Completata
Fully Delivered,Livrat complet
Furniture and Fixture,Și mobilier
Further accounts can be made under Groups but entries can be made against Ledger,Conturile suplimentare pot fi făcute sub Grupa dar intrări pot fi făcute împotriva Ledger
"Further accounts can be made under Groups, but entries can be made against Ledger","Conturile suplimentare pot fi făcute în grupurile, dar înregistrări pot fi făcute împotriva Ledger"
Further nodes can be only created under 'Group' type nodes,"Noduri suplimentare pot fi create numai în noduri de tip ""grup"""
GL Entry,GL de intrare
Gantt Chart,Gantt Chart
Gantt chart of all tasks.,Diagrama Gantt a tuturor sarcinilor.
Gender,Sex
General,Generală
General Ledger,General Ledger
Generate Description HTML,Genera Descriere HTML
Generate Material Requests (MRP) and Production Orders.,Genera Cererile de materiale (MRP) și comenzi de producție.
Generate Salary Slips,Genera salariale Alunecările
Generate Schedule,Genera Program
Generates HTML to include selected image in the description,Genereaza HTML pentru a include imagini selectate în descrierea
Get Advances Paid,Ia avansurile plătite
Get Advances Received,Ia Avansuri primite
Get Current Stock,Get Current Stock
Get Items,Ia Articole
Get Items From Sales Orders,Obține elemente din comenzi de vânzări
Get Items from BOM,Obține elemente din BOM
Get Last Purchase Rate,Ia Ultima Rate de cumparare
Get Outstanding Invoices,Ia restante Facturi
Get Relevant Entries,Ia intrările relevante
Get Sales Orders,Ia comenzi de vânzări
Get Specification Details,Ia Specificatii Detalii
Get Stock and Rate,Ia Stock și Rate
Get Template,Ia Format
Get Terms and Conditions,Ia Termeni și condiții
Get Unreconciled Entries,Ia nereconciliate Entries
Get Weekly Off Dates,Ia săptămânal Off Perioada
"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.","Ia rata de evaluare și stocul disponibil la sursă / depozit țintă pe menționat detașarea data-timp. Dacă serializat element, vă rugăm să apăsați acest buton după ce a intrat nr de serie."
Global Defaults,Prestabilite la nivel mondial
Global POS Setting {0} already created for company {1},Setarea POS Global {0} deja creat pentru companie {1}
Global Settings,Setari Glob
"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""","Du-te la grupul corespunzător (de obicei, de aplicare a fondurilor> activele circulante> conturi bancare și de a crea un nou cont Ledger (făcând clic pe Adăugați pentru copii) de tip ""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.","Du-te la grupul corespunzător (de obicei, sursa de fonduri> pasivele curente> taxelor și impozitelor și a crea un nou cont Ledger (făcând clic pe Adăugați pentru copii) de tip ""fiscal"", și menționează rata de impozitare."
Goal,Scop
Goals,Obiectivele
Goods received from Suppliers.,Bunurile primite de la furnizori.
Google Drive,Google Drive
Google Drive Access Allowed,Google unitate de acces permise
Government,Guvern
Graduate,Absolvent
Grand Total,Total general
Grand Total (Company Currency),Total general (Compania de valuta)
"Grid ""","Grid """
Grocery,Băcănie
Gross Margin %,Marja bruta%
Gross Margin Value,Valoarea brută Marja de
Gross Pay,Pay brut
Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,Brut Suma de plată + restante Suma + încasări - Total Deducerea
Gross Profit,Profitul brut
Gross Profit (%),Profit brut (%)
Gross Weight,Greutate brut
Gross Weight UOM,Greutate brută UOM
Group,Grup
Group by Account,Grup de Cont
Group by Voucher,Grup de Voucher
Group or Ledger,Grup sau Ledger
Groups,Grupuri
HR Manager,Manager Resurse Umane
HR Settings,Setări HR
HTML / Banner that will show on the top of product list.,"HTML / Banner, care va arăta pe partea de sus a listei de produse."
Half Day,Jumătate de zi
Half Yearly,Semestrial
Half-yearly,Semestrial
Happy Birthday!,La multi ani!
Hardware,Hardware
Has Batch No,Are lot Nu
Has Child Node,Are Nod copii
Has Serial No,Are de ordine
Head of Marketing and Sales,Director de Marketing și Vânzări
Header,Antet
Health Care,Health
Health Concerns,Probleme de sanatate
Health Details,Sănătate Detalii
Held On,A avut loc pe
Help HTML,Ajutor HTML
"Help: To link to another record in the system, use ""#Form/Note/[Note Name]"" as the Link URL. (don't use ""http://"")","Ajutor: Pentru a lega la altă înregistrare în sistem, utilizați ""# Form / Note / [Nota Name]"" ca URL Link. (Nu folositi ""http://"")"
"Here you can maintain family details like name and occupation of parent, spouse and children","Aici vă puteți menține detalii de familie cum ar fi numele și ocupația de mamă, soție și copii"
"Here you can maintain height, weight, allergies, medical concerns etc","Aici vă puteți menține inaltime, greutate, alergii, probleme medicale etc"
Hide Currency Symbol,Ascunde Valuta Simbol
High,Ridicată
History In Company,Istoric In companiei
Hold,Păstrarea / Ţinerea / Deţinerea
Holiday,Vacanță
Holiday List,Lista de vacanță
Holiday List Name,Denumire Lista de vacanță
Holiday master.,Maestru de vacanta.
Holidays,Concediu
Home,Acasă
Host,Găzduirea
"Host, Email and Password required if emails are to be pulled","Gazdă, e-mail și parola necesare în cazul în care e-mailuri să fie tras"
Hour,Oră
Hour Rate,Rate oră
Hour Rate Labour,Ora Rate de muncă
Hours,Ore
How Pricing Rule is applied?,Cum se aplică regula pret?
How frequently?,Cât de des?
"How should this currency be formatted? If not set, will use system defaults","Cum ar trebui să fie formatat aceasta moneda? Dacă nu setați, va folosi valorile implicite de sistem"
Human Resources,Managementul resurselor umane
Identification of the package for the delivery (for print),Identificarea pachetului de livrare (pentru imprimare)
If Income or Expense,În cazul în care venituri sau cheltuieli
If Monthly Budget Exceeded,Dacă bugetul lunar depășită
"If Sale BOM is defined, the actual BOM of the Pack is displayed as table. Available in Delivery Note and Sales Order","Dacă Vanzare BOM este definit, BOM efectivă a Pack este afișat ca masă. Disponibil în nota de livrare și comenzilor de vânzări"
"If Supplier Part Number exists for given Item, it gets stored here","În cazul în care există Number Furnizor parte pentru postul dat, ea este stocat aici"
If Yearly Budget Exceeded,Dacă bugetul anual depășită
"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.","Dacă este bifată, BOM pentru un produs sub-asamblare vor fi luate în considerare pentru a obține materii prime. În caz contrar, toate elementele de sub-asamblare va fi tratată ca o materie primă."
"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Dacă este bifată, nu total. de zile de lucru va include concediu, iar acest lucru va reduce valoarea Salariul pe zi"
"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Dacă este bifată, suma taxei va fi considerată ca fiind deja incluse în Print Tarif / Print Suma"
If different than customer address,Dacă este diferită de adresa clientului
"If disable, 'Rounded Total' field will not be visible in any transaction","Dacă dezactivați, câmpul ""rotunjit Total"" nu vor fi vizibile în orice tranzacție"
"If enabled, the system will post accounting entries for inventory automatically.","Dacă este activat, sistemul va posta automat înregistrări contabile pentru inventar."
If more than one package of the same type (for print),În cazul în care mai mult de un pachet de același tip (de imprimare)
"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","În cazul în care mai multe reguli de stabilire a prețurilor continuă să prevaleze, utilizatorii sunt rugați să setați manual prioritate pentru a rezolva conflictul."
"If no change in either Quantity or Valuation Rate, leave the cell blank.","În cazul în care nici o schimbare în nici Cantitate sau Evaluează evaluare, lăsați necompletată celula."
If not applicable please enter: NA,"Dacă nu este cazul, vă rugăm să introduceți: NA"
"If not checked, the list will have to be added to each Department where it has to be applied.","Dacă nu verificat, lista trebuie să fie adăugate la fiecare Departament unde trebuie aplicată."
"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.","Dacă Regula Preturi selectat se face pentru ""Pret"", se va suprascrie lista de prețuri. Preț Regula de stabilire a prețurilor este prețul final, astfel încât ar trebui să se aplice nici o reducere în continuare. Prin urmare, în tranzacții, cum ar fi Vânzări Ordine, Ordinul de cumparare, etc, el va fi preluat în câmpul ""Rate"", domeniul ""Lista de prețuri Rate"", mai degrabă decât."
"If specified, send the newsletter using this email address","Daca este specificat, trimite newsletter-ul prin această adresă de e-mail"
"If the account is frozen, entries are allowed to restricted users.","În cazul în care contul este blocat, intrările li se permite utilizatorilor restricționate."
"If this Account represents a Customer, Supplier or Employee, set it here.","În cazul în care acest cont reprezintă un client, furnizor sau angajat, a stabilit aici."
"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.","În cazul în care se găsesc două sau mai multe reguli de stabilire a prețurilor în funcție de condițiile de mai sus, se aplică prioritate. Prioritatea este un număr între 0 și 20 în timp ce valoarea implicită este zero (martor). Număr mai mare înseamnă că va avea prioritate în cazul în care există mai multe reguli de stabilire a prețurilor, cu aceleași condiții."
If you follow Quality Inspection. Enables Item QA Required and QA No in Purchase Receipt,Dacă urmați Inspecție de calitate. Permite Articol QA obligatorii și de asigurare a calității nu în Primirea cumparare
If you have Sales Team and Sale Partners (Channel Partners)  they can be tagged and maintain their contribution in the sales activity,"Dacă aveți echipa de vanzari si vandute Partners (parteneri), ele pot fi etichetate și menține contribuția lor la activitatea de vânzări"
"If you have created a standard template in Purchase Taxes and Charges Master, select one and click on the button below.","Dacă ați creat un model standard la taxele de cumpărare și de masterat taxe, selectați una și faceți clic pe butonul de mai jos."
"If you have created a standard template in Sales Taxes and Charges Master, select one and click on the button below.","Dacă ați creat un model standard la taxele de vânzare și de masterat taxe, selectați una și faceți clic pe butonul de mai jos."
"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","Dacă aveți formate de imprimare lungi, această caracteristică poate fi folosit pentru a împărți pagina pentru a fi imprimate pe mai multe pagini, cu toate anteturile și subsolurile de pe fiecare pagină"
If you involve in manufacturing activity. Enables Item 'Is Manufactured',"Dacă vă implica în activitatea de producție. Permite Articol ""este fabricat"""
Ignore,Ignora
Ignore Pricing Rule,Ignora Regula Preturi
Ignored: ,
Image,Imagine
Image View,Imagine Vizualizare
Implementation Partner,Partener de punere în aplicare
Import Attendance,Import Spectatori
Import Failed!,Import a eșuat!
Import Log,Import Conectare
Import Successful!,Importa cu succes!
Imports,Importurile
In Hours,În ore
In Process,În procesul de
In Qty,În Cantitate
In Value,În valoare
In Words,În cuvinte
In Words (Company Currency),În cuvinte (Compania valutar)
In Words (Export) will be visible once you save the Delivery Note.,În cuvinte (de export) va fi vizibil după ce a salva de livrare Nota.
In Words will be visible once you save the Delivery Note.,În cuvinte va fi vizibil după ce a salva de livrare Nota.
In Words will be visible once you save the Purchase Invoice.,În cuvinte va fi vizibil după ce salvați factura de cumpărare.
In Words will be visible once you save the Purchase Order.,În cuvinte va fi vizibil după ce a salva Ordinul de cumparare.
In Words will be visible once you save the Purchase Receipt.,În cuvinte va fi vizibil după ce a salva chitanța.
In Words will be visible once you save the Quotation.,În cuvinte va fi vizibil după ce salvați citat.
In Words will be visible once you save the Sales Invoice.,În cuvinte va fi vizibil după ce a salva de vânzări factură.
In Words will be visible once you save the Sales Order.,În cuvinte va fi vizibil după ce a salva comanda de vânzări.
Incentives,Stimulente
Include Reconciled Entries,Includ intrările împăcat
Include holidays in Total no. of Working Days,Includ vacanțe în total nr. de zile lucrătoare
Income,Venit
Income / Expense,Venituri / cheltuieli
Income Account,Contul de venit
Income Booked,Venituri rezervat
Income Tax,Impozit pe venit
Income Year to Date,Venituri Anul curent
Income booked for the digest period,Venituri rezervat pentru perioada Digest
Incoming,Primite
Incoming Rate,Rate de intrare
Incoming quality inspection.,Control de calitate de intrare.
Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Număr incorect de contabilitate intrările găsit. Este posibil să fi selectat un cont greșit în tranzacție.
Incorrect or Inactive BOM {0} for Item {1} at row {2},Incorectă sau inactivă BOM {0} pentru postul {1} la rând {2}
Indicates that the package is a part of this delivery (Only Draft),Indică faptul că pachetul este o parte din această livrare (Proiect de numai)
Indirect Expenses,Cheltuieli indirecte
Indirect Income,Venituri indirecte
Individual,Individual
Industry,Industrie
Industry Type,Industrie Tip
Inspected By,Inspectat de
Inspection Criteria,Criteriile de inspecție
Inspection Required,Inspecție obligatorii
Inspection Type,Inspecție Tip
Installation Date,Data de instalare
Installation Note,Instalare Notă
Installation Note Item,Instalare Notă Postul
Installation Note {0} has already been submitted,Instalarea Nota {0} a fost deja prezentat
Installation Status,Starea de instalare
Installation Time,Timp de instalare
Installation date cannot be before delivery date for Item {0},Data de instalare nu poate fi înainte de data de livrare pentru postul {0}
Installation record for a Serial No.,Înregistrare de instalare pentru un nr de serie
Installed Qty,Instalat Cantitate
Instructions,Instrucţiuni
Integrate incoming support emails to Support Ticket,Integra e-mailuri de sprijin primite de suport de vânzare bilete
Interested,Interesat
Intern,Interna
Internal,Intern
Internet Publishing,Editura Internet
Introduction,Introducere
Invalid Barcode,Coduri de bare invalid
Invalid Barcode or Serial No,Coduri de bare invalid sau de ordine
Invalid Mail Server. Please rectify and try again.,Server de mail invalid. Vă rugăm să rectifice și să încercați din nou.
Invalid Master Name,Maestru valabil Numele
Invalid User Name or Support Password. Please rectify and try again.,Nume utilizator invalid sau suport Parola. Vă rugăm să rectifice și să încercați din nou.
Invalid quantity specified for item {0}. Quantity should be greater than 0.,Cantitate nevalidă specificată pentru element {0}. Cantitatea ar trebui să fie mai mare decât 0.
Inventory,Inventarierea
Inventory & Support,Inventarul & Suport
Investment Banking,Investment Banking
Investments,Investiții
Invoice Date,Data facturii
Invoice Details,Factură Detalii
Invoice No,Factura Nu
Invoice Number,Numar factura
Invoice Period From,Perioada factura la
Invoice Period From and Invoice Period To dates mandatory for recurring invoice,Perioada factura la și facturilor perioadă la date obligatorii pentru facturi recurente
Invoice Period To,Perioada de facturare a
Invoice Type,Factura Tip
Invoice/Journal Voucher Details,Factura / Jurnalul Voucher Detalii
Invoiced Amount (Exculsive Tax),Facturate Suma (Exculsive Tax)
Is Active,Este activ
Is Advance,Este Advance
Is Cancelled,Este anulat
Is Carry Forward,Este Carry Forward
Is Default,Este Implicit
Is Encash,Este încasa
Is Fixed Asset Item,Este fixă Asset Postul
Is LWP,Este LWP
Is Opening,Se deschide
Is Opening Entry,Deschiderea este de intrare
Is POS,Este POS
Is Primary Contact,Este primar Contact
Is Purchase Item,Este de cumparare Articol
Is Sales Item,Este produs de vânzări
Is Service Item,Este Serviciul Articol
Is Stock Item,Este Stock Articol
Is Sub Contracted Item,Este subcontractate Postul
Is Subcontracted,Este subcontractată
Is this Tax included in Basic Rate?,Este acest fiscală inclusă în rata de bază?
Issue,Problem
Issue Date,Data emiterii
Issue Details,Detalii emisiune
Issued Items Against Production Order,Emise Articole împotriva producției de comandă
It can also be used to create opening stock entries and to fix stock value.,Acesta poate fi de asemenea utilizat pentru a crea intrări de stocuri de deschidere și de a stabili o valoare de stoc.
Item,Obiect
Item Advanced,Articol avansate
Item Barcode,Element de coduri de bare
Item Batch Nos,Lot nr element
Item Code,Cod articol
Item Code > Item Group > Brand,Cod articol> Articol Grupa> Brand
Item Code and Warehouse should already exist.,Articol Cod și Warehouse trebuie să existe deja.
Item Code cannot be changed for Serial No.,Cod articol nu pot fi schimbate pentru Serial No.
Item Code is mandatory because Item is not automatically numbered,"Cod articol este obligatorie, deoarece postul nu este numerotat automat"
Item Code required at Row No {0},Cod element necesar la Row Nu {0}
Item Customer Detail,Articol client Detaliu
Item Description,Element Descriere
Item Desription,Element Descrierea hotelelor
Item Details,Detalii despre articol
Item Group,Grupa de articole
Item Group Name,Nume Grupa de articole
Item Group Tree,Grupa de articole copac
Item Group not mentioned in item master for item {0},Grupa de articole care nu sunt menționate la punctul de master pentru element {0}
Item Groups in Details,Articol Grupuri în Detalii
Item Image (if not slideshow),Element de imagine (dacă nu slideshow)
Item Name,Denumire
Item Naming By,Element de denumire prin
Item Price,Preț de vanzare
Item Prices,Postul Preturi
Item Quality Inspection Parameter,Articol Inspecție de calitate Parametru
Item Reorder,Element Reordonare
Item Serial No,Element de ordine
Item Serial Nos,Element de serie nr
Item Shortage Report,Element Lipsa Raport
Item Supplier,Element Furnizor
Item Supplier Details,Detalii articol Furnizor
Item Tax,Postul fiscal
Item Tax Amount,Postul fiscal Suma
Item Tax Rate,Articol Rata de impozitare
Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Postul fiscal Row {0} trebuie sa aiba cont de tip fiscal sau de venituri sau cheltuieli sau taxabile
Item Tax1,Element Tax1
Item To Manufacture,Element pentru fabricarea
Item UOM,Element UOM
Item Website Specification,Articol Site Specificații
Item Website Specifications,Articol Site Specificații
Item Wise Tax Detail,Articol înțelept fiscală Detaliu
Item Wise Tax Detail ,
Item is required,Este necesară Articol
Item is updated,Element este actualizat
Item master.,Maestru element.
"Item must be a purchase item, as it is present in one or many Active BOMs","Element trebuie să fie un element de cumpărare, așa cum este prezent în unul sau mai multe extraselor active"
Item or Warehouse for row {0} does not match Material Request,Element sau Depozit de rând {0} nu se potrivește Material Cerere
Item table can not be blank,Masă element nu poate fi gol
Item to be manufactured or repacked,Element care urmează să fie fabricate sau reambalate
Item valuation updated,Evaluare element actualizat
Item will be saved by this name in the data base.,Articol vor fi salvate de acest nume în baza de date.
Item {0} appears multiple times in Price List {1},Element {0} apare de mai multe ori în lista de prețuri {1}
Item {0} does not exist,Element {0} nu există
Item {0} does not exist in the system or has expired,Element {0} nu există în sistemul sau a expirat
Item {0} does not exist in {1} {2},Element {0} nu există în {1} {2}
Item {0} has already been returned,Element {0} a fost deja returnate
Item {0} has been entered multiple times against same operation,Element {0} a fost introdus de mai multe ori față de aceeași operație
Item {0} has been entered multiple times with same description or date,Element {0} a fost introdus de mai multe ori cu aceeași descriere sau data
Item {0} has been entered multiple times with same description or date or warehouse,Element {0} a fost introdus de mai multe ori cu aceeași descriere sau data sau antrepozit
Item {0} has been entered twice,Element {0} a fost introdusă de două ori
Item {0} has reached its end of life on {1},Element {0} a ajuns la sfârșitul său de viață pe {1}
Item {0} ignored since it is not a stock item,"Element {0} ignorat, deoarece nu este un element de stoc"
Item {0} is cancelled,Element {0} este anulat
Item {0} is not Purchase Item,Element {0} nu este cumparare articol
Item {0} is not a serialized Item,Element {0} nu este un element serializate
Item {0} is not a stock Item,Element {0} nu este un element de stoc
Item {0} is not active or end of life has been reached,Element {0} nu este activă sau la sfârșitul vieții a fost atins
Item {0} is not setup for Serial Nos. Check Item master,Element {0} nu este de configurare pentru maestru nr Serial de selectare a elementului
Item {0} is not setup for Serial Nos. Column must be blank,Element {0} nu este de configurare pentru Serial Nr Coloana trebuie să fie gol
Item {0} must be Sales Item,Element {0} trebuie să fie produs de vânzări
Item {0} must be Sales or Service Item in {1},Element {0} trebuie să fie vânzări sau de service Articol din {1}
Item {0} must be Service Item,Element {0} trebuie să fie de service Articol
Item {0} must be a Purchase Item,Element {0} trebuie sa fie un element de cumparare
Item {0} must be a Sales Item,Element {0} trebuie sa fie un element de vânzări
Item {0} must be a Service Item.,Element {0} trebuie sa fie un element de service.
Item {0} must be a Sub-contracted Item,Element {0} trebuie sa fie un element sub-contractat
Item {0} must be a stock Item,Element {0} trebuie sa fie un element de stoc
Item {0} must be manufactured or sub-contracted,Element {0} trebuie să fie fabricate sau sub-contractat
Item {0} not found,Element {0} nu a fost găsit
Item {0} with Serial No {1} is already installed,Element {0} cu ordine {1} este deja instalat
Item {0} with same description entered twice,Element {0} cu aceeași descriere a intrat de două ori
"Item, Warranty, AMC (Annual Maintenance Contract) details will be automatically fetched when Serial Number is selected.","Element, Garantie, AMC (de întreținere anuale contractului) detalii vor fi preluate în mod automat atunci când este selectat numărul de serie."
Item-wise Price List Rate,-Element înțelept Pret Rate
Item-wise Purchase History,-Element înțelept Istoricul achizițiilor
Item-wise Purchase Register,-Element înțelept cumparare Inregistrare
Item-wise Sales History,-Element înțelept Sales Istorie
Item-wise Sales Register,-Element înțelept vânzări Înregistrare
"Item: {0} managed batch-wise, can not be reconciled using \
					Stock Reconciliation, instead use Stock Entry","Postul: {0}-lot înțelept a reușit, nu pot fi reconciliate cu ajutorul \
 Bursa de reconciliere, folosiți în schimb Bursa de intrare"
Item: {0} not found in the system,Postul: {0} nu a fost găsit în sistemul
Items,Obiecte
Items To Be Requested,Elemente care vor fi solicitate
Items required,Elementele necesare
"Items to be requested which are ""Out of Stock"" considering all warehouses based on projected qty and minimum order qty","Elementele care urmează să fie solicitate care sunt ""in stoc"", luând în considerare toate depozitele bazate pe cantitate proiectat și comanda minima Cantitate"
Items which do not exist in Item master can also be entered on customer's request,"Elemente care nu există în maestru articol poate fi, de asemenea, introduse la cererea clientului"
Itemwise Discount,Itemwise Reducere
Itemwise Recommended Reorder Level,Itemwise Recomandat Reordonare nivel
Job Applicant,Solicitantul de locuri de muncă
Job Opening,Deschiderea de locuri de muncă
Job Profile,De locuri de muncă Profilul
Job Title,Denumirea postului
"Job profile, qualifications required etc.","Profil de locuri de muncă, calificările necesare, etc"
Jobs Email Settings,Setări de locuri de muncă de e-mail
Journal Entries,Intrari in jurnal
Journal Entry,Jurnal de intrare
Journal Voucher,Jurnalul Voucher
Journal Voucher Detail,Jurnalul Voucher Detaliu
Journal Voucher Detail No,Jurnalul Voucher Detaliu Nu
Journal Voucher {0} does not have account {1} or already matched,Jurnalul Voucher {0} nu are cont {1} sau deja potrivire
Journal Vouchers {0} are un-linked,Jurnalul Tichete {0} sunt ne-legate de
Keep a track of communication related to this enquiry which will help for future reference.,"Păstra o pistă de comunicare legate de această anchetă, care va ajuta de referință pentru viitor."
Keep it web friendly 900px (w) by 100px (h),Păstrați-l web 900px prietenos (w) de 100px (h)
Key Performance Area,Domeniul Major de performanță
Key Responsibility Area,Domeniul Major de Responsabilitate
Kg,Kg
LR Date,LR Data
LR No,LR Nu
Label,Etichetarea
Landed Cost Item,Aterizat Cost Articol
Landed Cost Items,Aterizat cost Articole
Landed Cost Purchase Receipt,Aterizat costul de achiziție de primire
Landed Cost Purchase Receipts,Aterizat Încasări costul de achiziție
Landed Cost Wizard,Wizard Cost aterizat
Landed Cost updated successfully,Costul aterizat actualizat cu succes
Language,Limbă
Last Name,Nume
Last Purchase Rate,Ultima Rate de cumparare
Latest,Ultimele
Lead,Șef
Lead Details,Plumb Detalii
Lead Id,Plumb Id
Lead Name,Numele plumb
Lead Owner,Plumb Proprietar
Lead Source,Sursa de plumb
Lead Status,Starea de plumb
Lead Time Date,Data de livrare
Lead Time Days,De livrare Zile
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.,Plumb de zile de timp este numărul de zile cu care acest element este de așteptat în depozit. Această zi este descărcat în Material Cerere atunci când selectați acest element.
Lead Type,Tip Plumb
Lead must be set if Opportunity is made from Lead,Plumb trebuie să fie setat dacă Oportunitatea este facut din plumb
Leave Allocation,Lasă Alocarea
Leave Allocation Tool,Lasă Alocarea Tool
Leave Application,Lasă Application
Leave Approver,Lasă aprobator
Leave Approvers,Lasă Aprobatori
Leave Balance Before Application,Lasă Balanța înainte de aplicare
Leave Block List,Lasă Lista Block
Leave Block List Allow,Lasă Block List Permite
Leave Block List Allowed,Lasă Block List permise
Leave Block List Date,Lasă Block List Data
Leave Block List Dates,Lasă Block Lista de Date
Leave Block List Name,Lasă Name Block List
Leave Blocked,Lasă Blocat
Leave Control Panel,Pleca Control Panel
Leave Encashed?,Lasă încasate?
Leave Encashment Amount,Lasă încasări Suma
Leave Type,Lasă Tip
Leave Type Name,Lasă Tip Nume
Leave Without Pay,Concediu fără plată
Leave application has been approved.,Cerere de concediu a fost aprobat.
Leave application has been rejected.,Cerere de concediu a fost respinsă.
Leave approver must be one of {0},Lasă aprobator trebuie să fie una din {0}
Leave blank if considered for all branches,Lăsați necompletat dacă se consideră că pentru toate ramurile
Leave blank if considered for all departments,Lăsați necompletat dacă se consideră că pentru toate departamentele
Leave blank if considered for all designations,Lăsați necompletat dacă se consideră că pentru toate denumirile
Leave blank if considered for all employee types,Lăsați necompletat dacă se consideră că pentru toate tipurile de angajați
"Leave can be approved by users with Role, ""Leave Approver""","Lasă pot fi aprobate de către utilizatorii cu rol, ""Lasă-aprobator"""
Leave of type {0} cannot be longer than {1},Concediu de tip {0} nu poate fi mai mare de {1}
Leaves Allocated Successfully for {0},Frunze alocat cu succes pentru {0}
Leaves for type {0} already allocated for Employee {1} for Fiscal Year {0},Frunze de tip {0} deja alocate pentru Angajat {1} pentru anul fiscal {0}
Leaves must be allocated in multiples of 0.5,"Frunzele trebuie să fie alocate în multipli de 0,5"
Ledger,Carte mare
Ledgers,Registre
Left,Stânga
Legal,Legal
Legal Expenses,Cheltuieli juridice
Letter Head,Scrisoare cap
Letter Heads for print templates.,Capete de scrisoare de șabloane de imprimare.
Level,Nivel
Lft,LFT
Liability,Răspundere
List a few of your customers. They could be organizations or individuals.,Lista câteva dintre clienții dumneavoastră. Ele ar putea fi organizații sau persoane fizice.
List a few of your suppliers. They could be organizations or individuals.,Lista câteva dintre furnizorii dumneavoastră. Ele ar putea fi organizații sau persoane fizice.
List items that form the package.,Lista de elemente care formează pachetul.
List this Item in multiple groups on the website.,Lista acest articol în mai multe grupuri de pe site-ul.
"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.","Lista de produse sau servicii pe care le cumpara sau vinde tale. Asigurați-vă că pentru a verifica Grupului articol, unitatea de măsură și alte proprietăți atunci când începe."
"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.","Lista capetele fiscale (de exemplu, TVA, accize, acestea ar trebui să aibă nume unice) și ratele lor standard. Acest lucru va crea un model standard, pe care le puteți edita și adăuga mai târziu."
Loading...,Încărcare...
Loans (Liabilities),Credite (pasive)
Loans and Advances (Assets),Împrumuturi și avansuri (Active)
Local,Local
Login,Conectare
Login with your new User ID,Autentifica-te cu noul ID utilizator
Logo,Logo
Logo and Letter Heads,Logo și Scrisoare Heads
Lost,Pierdut
Lost Reason,Expunere de motive a pierdut
Low,Scăzut
Lower Income,Venituri mai mici
MTN Details,MTN Detalii
Main,Principal
Main Reports,Rapoarte principale
Maintain Same Rate Throughout Sales Cycle,Menține aceeași rată de-a lungul ciclului de vânzări
Maintain same rate throughout purchase cycle,Menține aceeași rată de-a lungul ciclului de cumpărare
Maintenance,Mentenanţă
Maintenance Date,Data întreținere
Maintenance Details,Detalii întreținere
Maintenance Schedule,Program de întreținere
Maintenance Schedule Detail,Program de întreținere Detaliu
Maintenance Schedule Item,Program de întreținere Articol
Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Program de întreținere nu este generată pentru toate elementele. Vă rugăm să faceți clic pe ""Generate Program"""
Maintenance Schedule {0} exists against {0},Program de întreținere {0} există în {0}
Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Program de întreținere {0} trebuie anulată înainte de a anula această comandă de vânzări
Maintenance Schedules,Orarele de întreținere
Maintenance Status,Starea de întreținere
Maintenance Time,Timp de întreținere
Maintenance Type,Tip de întreținere
Maintenance Visit,Vizitează întreținere
Maintenance Visit Purpose,Vizitează întreținere Scop
Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Vizitează întreținere {0} trebuie anulată înainte de a anula această comandă de vânzări
Maintenance start date can not be before delivery date for Serial No {0},Întreținere data de începere nu poate fi înainte de data de livrare pentru de serie nr {0}
Major/Optional Subjects,Subiectele majore / opționale
Make ,
Make Accounting Entry For Every Stock Movement,Asigurați-vă de contabilitate de intrare pentru fiecare Stock Mișcarea
Make Bank Voucher,Banca face Voucher
Make Credit Note,Face Credit Nota
Make Debit Note,Face notă de debit
Make Delivery,Face de livrare
Make Difference Entry,Face diferenta de intrare
Make Excise Invoice,Face accize Factura
Make Installation Note,Face de instalare Notă
Make Invoice,Face Factura
Make Maint. Schedule,Face Maint. Program
Make Maint. Visit,Face Maint. Vizita
Make Maintenance Visit,Face de întreținere Vizitați
Make Packing Slip,Face bonul
Make Payment,Face plată
Make Payment Entry,Face plată de intrare
Make Purchase Invoice,Face cumparare factură
Make Purchase Order,Face Comandă
Make Purchase Receipt,Face Primirea de cumparare
Make Salary Slip,Face Salariul Slip
Make Salary Structure,Face Structura Salariul
Make Sales Invoice,Face Factura Vanzare
Make Sales Order,Face comandă de vânzări
Make Supplier Quotation,Face Furnizor ofertă
Make Time Log Batch,Ora face Log lot
Male,Masculin
Manage Customer Group Tree.,Gestiona Customer Group copac.
Manage Sales Partners.,Gestiona vânzările Partners.
Manage Sales Person Tree.,Gestiona vânzările Persoana copac.
Manage Territory Tree.,Gestiona Teritoriul copac.
Manage cost of operations,Gestiona costul operațiunilor
Management,"Controlul situatiilor, (managementul)"
Manager,Manager
"Mandatory if Stock Item is ""Yes"". Also the default warehouse where reserved quantity is set from Sales Order.","Obligatoriu dacă Piesa este ""da"". De asemenea, depozitul implicit în cazul în care cantitatea rezervat este stabilit de comandă de vânzări."
Manufacture against Sales Order,Fabricarea de comandă de vânzări
Manufacture/Repack,Fabricarea / Repack
Manufactured Qty,Produs Cantitate
Manufactured quantity will be updated in this warehouse,Cantitate fabricat va fi actualizată în acest depozit
Manufactured quantity {0} cannot be greater than planned quanitity {1} in Production Order {2},Cantitate fabricat {0} nu poate fi mai mare decât avantajeje planificat {1} în producție Ordine {2}
Manufacturer,Producător
Manufacturer Part Number,Numarul de piesa
Manufacturing,De fabricație
Manufacturing Quantity,Cantitatea de fabricație
Manufacturing Quantity is mandatory,Cantitatea de fabricație este obligatorie
Margin,Margin
Marital Status,Stare civilă
Market Segment,Segmentul de piață
Marketing,Marketing
Marketing Expenses,Cheltuieli de marketing
Married,Căsătorit
Mass Mailing,Corespondență în masă
Master Name,Maestru Nume
Master Name is mandatory if account type is Warehouse,Maestrul Numele este obligatorie dacă tipul de cont este de depozit
Master Type,Maestru Tip
Masters,Masterat
Match non-linked Invoices and Payments.,Potrivesc Facturi non-legate și plăți.
Material Issue,Problema de material
Material Receipt,Primirea de material
Material Request,Cerere de material
Material Request Detail No,Material Cerere Detaliu Nu
Material Request For Warehouse,Cerere de material Pentru Warehouse
Material Request Item,Material Cerere Articol
Material Request Items,Material Cerere Articole
Material Request No,Cerere de material Nu
Material Request Type,Material Cerere tip
Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Cerere de material de maximum {0} se poate face pentru postul {1} împotriva comandă de vânzări {2}
Material Request used to make this Stock Entry,Cerere de material utilizat pentru a face acest stoc de intrare
Material Request {0} is cancelled or stopped,Cerere de material {0} este anulată sau oprită
Material Requests for which Supplier Quotations are not created,Cererile de materiale pentru care nu sunt create Cotațiile Furnizor
Material Requests {0} created,Cererile de materiale {0} a creat
Material Requirement,Cerința de material
Material Transfer,Transfer de material
Materials,Materiale
Materials Required (Exploded),Materiale necesare (explodat)
Max 5 characters,Max 5 caractere
Max Days Leave Allowed,Max zile de concediu de companie
Max Discount (%),Max Discount (%)
Max Qty,Max Cantitate
Max discount allowed for item: {0} is {1}%,Discount maxim permis pentru articol: {0} este {1}%
Maximum Amount,Suma maximă
Maximum allowed credit is {0} days after posting date,Credit maximă permisă este de {0} zile de la postarea data
Maximum {0} rows allowed,Maxime {0} rânduri permis
Maxiumm discount for Item {0} is {1}%,Reducere Maxiumm pentru postul {0} este {1}%
Medical,Medical
Medium,Medie
"Merging is only possible if following properties are same in both records. Group or Ledger, Root Type, Company","Fuzionarea este posibilă numai în cazul în care următoarele proprietăți sunt aceleași în ambele registre. Grup sau Ledger, Root tip, de companie"
Message,Mesaj
Message Parameter,Parametru mesaj
Message Sent,Mesajul a fost trimis
Message updated,Mesaj Actualizat
Messages,Mesaje
Messages greater than 160 characters will be split into multiple messages,Mesaje mai mari de 160 de caractere vor fi împărțite în mai multe mesaje
Middle Income,Venituri medii
Milestone,Milestone
Milestone Date,Milestone Data
Milestones,Repere
Milestones will be added as Events in the Calendar,Repere vor fi adăugate ca evenimente din calendarul
Min Order Qty,Min Ordine Cantitate
Min Qty,Min Cantitate
Min Qty can not be greater than Max Qty,Min Cantitate nu poate fi mai mare decât Max Cantitate
Minimum Amount,Suma minima
Minimum Order Qty,Comanda minima Cantitate
Minute,Minut
Misc Details,Misc Detalii
Miscellaneous Expenses,Cheltuieli diverse
Miscelleneous,Miscelleneous
Mobile No,Mobil Nu
Mobile No.,Mobil Nu.
Mode of Payment,Mod de plata
Modern,Modern
Monday,Luni
Month,Lună
Monthly,Lunar
Monthly Attendance Sheet,Lunar foaia de prezență
Monthly Earning & Deduction,Câștigul salarial lunar & Deducerea
Monthly Salary Register,Salariul lunar Inregistrare
Monthly salary statement.,Declarația salariu lunar.
More Details,Mai multe detalii
More Info,Mai multe informatii
Motion Picture & Video,Motion Picture & Video
Moving Average,Mutarea medie
Moving Average Rate,Rata medie mobilă
Mr,Mr
Ms,Ms
Multiple Item prices.,Mai multe prețuri element.
"Multiple Price Rule exists with same criteria, please resolve \
			conflict by assigning priority. Price Rules: {0}","Există Prețul multiple Regula cu aceleași criterii, vă rugăm să rezolve \
 conflictelor de acordând prioritate. Reguli Pret: {0}"
Music,Muzica
Must be Whole Number,Trebuie să fie Număr întreg
Name,Nume
Name and Description,Nume și descriere
Name and Employee ID,Nume și ID angajat
"Name of new Account. Note: Please don't create accounts for Customers and Suppliers, they are created automatically from the Customer and Supplier master","Nume de nou cont. Notă: Vă rugăm să nu creați conturi pentru clienți și furnizori, ele sunt create în mod automat de la client și furnizor maestru"
Name of person or organization that this address belongs to.,Nume de persoană sau organizație care această adresă aparține.
Name of the Budget Distribution,Numele distribuția bugetului
Naming Series,Naming Series
Negative Quantity is not allowed,Negativ Cantitatea nu este permis
Negative Stock Error ({6}) for Item {0} in Warehouse {1} on {2} {3} in {4} {5},Eroare negativ Stock ({6}) pentru postul {0} în Depozit {1} la {2} {3} în {4} {5}
Negative Valuation Rate is not allowed,Negativ Rata de evaluare nu este permis
Negative balance in Batch {0} for Item {1} at Warehouse {2} on {3} {4},Sold negativ în Lot {0} pentru postul {1} la Warehouse {2} pe {3} {4}
Net Pay,Net plată
Net Pay (in words) will be visible once you save the Salary Slip.,Pay net (în cuvinte) vor fi vizibile după ce salvați fișa de salariu.
Net Profit / Loss,Profit / pierdere net
Net Total,Net total
Net Total (Company Currency),Net total (Compania de valuta)
Net Weight,Greutate netă
Net Weight UOM,Greutate neta UOM
Net Weight of each Item,Greutatea netă a fiecărui produs
Net pay cannot be negative,Salariul net nu poate fi negativ
Never,Niciodată
New ,
New Account,Cont nou
New Account Name,Nume nou cont
New BOM,Nou BOM
New Communications,Noi Comunicații
New Company,Noua companie
New Cost Center,Nou centru de cost
New Cost Center Name,New Cost Center Nume
New Delivery Notes,De livrare de noi Note
New Enquiries,Noi Intrebari
New Leads,Oportunitati noi
New Leave Application,Noua cerere de concediu
New Leaves Allocated,Frunze noi alocate
New Leaves Allocated (In Days),Frunze noi alocate (în zile)
New Material Requests,Noi cereri Material
New Projects,Proiecte noi
New Purchase Orders,Noi comenzi de aprovizionare
New Purchase Receipts,Noi Încasări de cumpărare
New Quotations,Noi Citatele
New Sales Orders,Noi comenzi de vânzări
New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Noua ordine nu pot avea Warehouse. Depozit trebuie să fie stabilite de către Bursa de intrare sau de primire de cumparare
New Stock Entries,Stoc nou Entries
New Stock UOM,Nou Stock UOM
New Stock UOM is required,New Stock UOM este necesar
New Stock UOM must be different from current stock UOM,New Stock UOM trebuie să fie diferit de curent stoc UOM
New Supplier Quotations,Noi Cotațiile Furnizor
New Support Tickets,Noi Bilete Suport
New UOM must NOT be of type Whole Number,New UOM nu trebuie să fie de tip Număr întreg
New Workplace,Nou la locul de muncă
Newsletter,Newsletter
Newsletter Content,Newsletter Conținut
Newsletter Status,Newsletter Starea
Newsletter has already been sent,Newsletter a fost deja trimisa
"Newsletters to contacts, leads.","Buletine de contacte, conduce."
Newspaper Publishers,Editorii de ziare
Next,Urmatorea
Next Contact By,Următor Contact Prin
Next Contact Date,Următor Contact Data
Next Date,Data viitoare
Next email will be sent on:,E-mail viitor va fi trimis la:
No,Nu
No Customer Accounts found.,Niciun Conturi client gasit.
No Customer or Supplier Accounts found,Nici un client sau furnizor Conturi a constatat
No Expense Approvers. Please assign 'Expense Approver' Role to atleast one user,"Nu sunt Aprobatori cheltuieli. Vă rugăm să atribui Rolul ""Cheltuieli aprobator"" la cel putin un utilizator"
No Item with Barcode {0},Nici un articol cu coduri de bare {0}
No Item with Serial No {0},Nici un articol cu ordine {0}
No Items to pack,Nu sunt produse în ambalaj
No Leave Approvers. Please assign 'Leave Approver' Role to atleast one user,"Nu sunt Aprobatori plece. Vă rugăm să atribui 'Leave aprobator ""Rolul de cel putin un utilizator"
No Permission,Lipsă acces
No Production Orders created,Nu sunt comenzile de producție create
No Supplier Accounts found. Supplier Accounts are identified based on 'Master Type' value in account record.,"Niciun Conturi Furnizor găsit. Conturile furnizorul sunt identificate pe baza valorii ""Maestru de tip"" în înregistrare cont."
No accounting entries for the following warehouses,Nici o intrare contabile pentru următoarele depozite
No addresses created,Nici o adresa create
No contacts created,Nici un contact create
No default Address Template found. Please create a new one from Setup > Printing and Branding > Address Template.,Nu Format implicit Adresa găsit. Vă rugăm să creați unul nou de la Setup> Imprimare și Branding> Format Adresa.
No default BOM exists for Item {0},Nu există implicit BOM pentru postul {0}
No description given,Nici o descriere dat
No employee found,Nu a fost gasit angajat
No employee found!,Nici un angajat nu a fost gasit!
No of Requested SMS,Nu de SMS solicitat
No of Sent SMS,Nu de SMS-uri trimise
No of Visits,Nu de vizite
No permission,Nici o permisiune
No record found,Nu au găsit înregistrări
No records found in the Invoice table,Nu sunt găsite în tabelul de factură înregistrări
No records found in the Payment table,Nu sunt găsite în tabelul de plăți înregistrări
No salary slip found for month: ,
Non Profit,Non-Profit
Nos,Nos
Not Active,Nu este activ
Not Applicable,Nu se aplică
Not Available,Indisponibil
Not Billed,Nu Taxat
Not Delivered,Nu Pronunțată
Not Set,Nu a fost setat
Not allowed to update stock transactions older than {0},Nu este permis să actualizeze tranzacțiile bursiere mai vechi de {0}
Not authorized to edit frozen Account {0},Nu este autorizat pentru a edita contul congelate {0}
Not authroized since {0} exceeds limits,Nu authroized din {0} depășește limitele
Not permitted,Nu este permisă
Note,Notă
Note User,Notă utilizator
"Note: Backups and files are not deleted from Dropbox, you will have to delete them manually.","Notă: Backup și fișierele nu sunt șterse de la Dropbox, va trebui să le ștergeți manual."
"Note: Backups and files are not deleted from Google Drive, you will have to delete them manually.","Notă: Backup și fișierele nu sunt șterse de pe Google Drive, va trebui să le ștergeți manual."
Note: Due Date exceeds the allowed credit days by {0} day(s),Notă: Datorită Data depășește zilele de credit permise de {0} zi (s)
Note: Email will not be sent to disabled users,Notă: Adresa de email nu va fi trimis la utilizatorii cu handicap
Note: Item {0} entered multiple times,Notă: Articol {0} a intrat de mai multe ori
Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Notă: Plata de intrare nu va fi creat deoarece ""Cash sau cont bancar"" nu a fost specificat"
Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,"Notă: Sistemul nu va verifica peste, livrare și supra-rezervări pentru postul {0} ca și cantitatea sau valoarea este 0"
Note: There is not enough leave balance for Leave Type {0},Notă: Nu este echilibrul concediu suficient pentru concediul de tip {0}
Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Notă: Acest centru de cost este un grup. Nu pot face înregistrări contabile impotriva grupuri.
Note: {0},Notă: {0}
Notes,Observații:
Notes:,Observații:
Nothing to request,Nimic de a solicita
Notice (days),Preaviz (zile)
Notification Control,Controlul notificare
Notification Email Address,Notificarea Adresa de e-mail
Notify by Email on creation of automatic Material Request,Notifica prin e-mail la crearea de cerere automată Material
Number Format,Număr Format
Offer Date,Oferta Date
Office,Birou
Office Equipments,Echipamente de birou
Office Maintenance Expenses,Cheltuieli de întreținere birou
Office Rent,Birou inchiriat
Old Parent,Vechi mamă
On Net Total,Pe net total
On Previous Row Amount,La rândul precedent Suma
On Previous Row Total,Inapoi la rândul Total
Online Auctions,Licitatii Online
Only Leave Applications with status 'Approved' can be submitted,"Lasă doar Aplicatii cu statutul de ""Aprobat"" pot fi depuse"
"Only Serial Nos with status ""Available"" can be delivered.","Numai Serial nr cu statutul ""Disponibile"", pot fi livrate."
Only leaf nodes are allowed in transaction,Numai noduri frunze sunt permise în tranzacție
Only the selected Leave Approver can submit this Leave Application,Numai selectat concediu aprobator poate înainta această aplicație Leave
Open,Deschide
Open Production Orders,Comenzi deschis de producție
Open Tickets,Bilete deschise
Opening (Cr),Deschidere (Cr)
Opening (Dr),Deschidere (Dr)
Opening Date,Data deschiderii
Opening Entry,Deschiderea de intrare
Opening Qty,Deschiderea Cantitate
Opening Time,Timp de deschidere
Opening Value,Valoare de deschidere
Opening for a Job.,Deschidere pentru un loc de muncă.
Operating Cost,Costul de operare
Operation Description,Operație Descriere
Operation No,Operațiunea nu
Operation Time (mins),Operațiunea Timp (min)
Operation {0} is repeated in Operations Table,Operațiunea {0} se repetă în Operations tabelul
Operation {0} not present in Operations Table,Operațiunea {0} nu este prezent în Operations tabelul
Operations,Operatii
Opportunity,Oportunitate
Opportunity Date,Oportunitate Data
Opportunity From,Oportunitate de la
Opportunity Item,Oportunitate Articol
Opportunity Items,Articole de oportunitate
Opportunity Lost,Oportunitate pierdută
Opportunity Type,Tip de oportunitate
Optional. This setting will be used to filter in various transactions.,Opțional. Această setare va fi utilizat pentru a filtra în diverse tranzacții.
Order Type,Tip comandă
Order Type must be one of {0},Pentru Tipul trebuie să fie una dintre {0}
Ordered,Ordonat
Ordered Items To Be Billed,Comandat de Articole Pentru a fi facturat
Ordered Items To Be Delivered,Comandat de elemente pentru a fi livrate
Ordered Qty,Ordonat Cantitate
"Ordered Qty: Quantity ordered for purchase, but not received.","Comandat Cantitate: Cantitatea comandat pentru cumpărare, dar nu a primit."
Ordered Quantity,Ordonat Cantitate
Orders released for production.,Comenzi lansat pentru producție.
Organization Name,Numele organizației
Organization Profile,Organizație de profil
Organization branch master.,Ramură organizație maestru.
Organization unit (department) master.,Unitate de organizare (departament) maestru.
Other,Altul
Other Details,Alte detalii
Others,Altel
Out Qty,Out Cantitate
Out Value,Out Valoarea
Out of AMC,Din AMC
Out of Warranty,Din garanție
Outgoing,Trimise
Outstanding Amount,Remarcabil Suma
Outstanding for {0} cannot be less than zero ({1}),Restante pentru {0} nu poate fi mai mică decât zero ({1})
Overhead,Deasupra
Overheads,Cheltuieli generale
Overlapping conditions found between:,Condiții se suprapun găsite între:
Overview,Prezentare generală
Owned,Owned
Owner,Proprietar
P L A - Cess Portion,PLA - Cess portii
PL or BS,PL sau BS
PO Date,PO Data
PO No,PO Nu
POP3 Mail Server,POP3 Mail Server
POP3 Mail Settings,POP3 Mail Settings
POP3 mail server (e.g. pop.gmail.com),Server de poștă electronică POP3 (de exemplu pop.gmail.com)
POP3 server e.g. (pop.gmail.com),Server de POP3 de exemplu (pop.gmail.com)
POS Setting,Setarea POS
POS Setting required to make POS Entry,Setarea POS necesare pentru a face POS intrare
POS Setting {0} already created for user: {1} and company {2},Setarea POS {0} deja creat pentru utilizator: {1} și companie {2}
POS View,POS View
PR Detail,PR Detaliu
Package Item Details,Detalii pachet Postul
Package Items,Pachet Articole
Package Weight Details,Pachetul Greutate Detalii
Packed Item,Articol ambalate
Packed quantity must equal quantity for Item {0} in row {1},Cantitate ambalate trebuie să fie egală cantitate pentru postul {0} în rândul {1}
Packing Details,Detalii de ambalare
Packing List,Lista de ambalare
Packing Slip,Slip de ambalare
Packing Slip Item,Bonul Articol
Packing Slip Items,Bonul de Articole
Packing Slip(s) cancelled,Slip de ambalare (e) anulate
Page Break,Page Break
Page Name,Nume pagină
Paid Amount,Suma plătită
Paid amount + Write Off Amount can not be greater than Grand Total,Suma plătită + Scrie Off Suma nu poate fi mai mare decât Grand total
Pair,Pereche
Parameter,Parametru
Parent Account,Contul părinte
Parent Cost Center,Părinte Cost Center
Parent Customer Group,Părinte Client Group
Parent Detail docname,Părinte Detaliu docname
Parent Item,Părinte Articol
Parent Item Group,Părinte Grupa de articole
Parent Item {0} must be not Stock Item and must be a Sales Item,Părinte Articol {0} nu trebuie să fie Stock Articol și trebuie să fie un element de vânzări
Parent Party Type,Tip Party părinte
Parent Sales Person,Mamă Sales Person
Parent Territory,Teritoriul părinte
Parent Website Page,Părinte Site Page
Parent Website Route,Părinte Site Route
Parenttype,ParentType
Part-time,Part-time
Partially Completed,Parțial finalizate
Partly Billed,Parțial Taxat
Partly Delivered,Parțial livrate
Partner Target Detail,Partener țintă Detaliu
Partner Type,Tip partener
Partner's Website,Site-ul partenerului
Party,Grup
Party Account,Party Account
Party Type,Tip de partid
Party Type Name,Tip partid Nume
Passive,Pasiv
Passport Number,Numărul de pașaport
Password,Parolă
Pay To / Recd From,Pentru a plăti / Recd de la
Payable,Plătibil
Payables,Datorii
Payables Group,Datorii Group
Payment Days,Zile de plată
Payment Due Date,Data scadentă de plată
Payment Period Based On Invoice Date,Perioada de plată Bazat pe Data facturii
Payment Reconciliation,Reconcilierea plată
Payment Reconciliation Invoice,Reconcilierea plata facturii
Payment Reconciliation Invoices,Facturi de reconciliere plată
Payment Reconciliation Payment,Reconciliere de plata
Payment Reconciliation Payments,Plăți de reconciliere plată
Payment Type,Tipul de plată
Payment cannot be made for empty cart,Plata nu se poate face pentru cart gol
Payment of salary for the month {0} and year {1},Plata salariului pentru luna {0} și {1 an}
Payments,Plăți
Payments Made,Plățile efectuate
Payments Received,Plăți primite
Payments made during the digest period,Plățile efectuate în timpul perioadei de rezumat
Payments received during the digest period,Plăților primite în perioada de rezumat
Payroll Settings,Setări de salarizare
Pending,În așteptarea
Pending Amount,În așteptarea Suma
Pending Items {0} updated,Elemente în curs de {0} actualizat
Pending Review,Revizuirea în curs
Pending SO Items For Purchase Request,Până la SO articole pentru cerere de oferta
Pension Funds,Fondurile de pensii
Percent Complete,La sută complet
Percentage Allocation,Alocarea procent
Percentage Allocation should be equal to 100%,Alocarea procent ar trebui să fie egală cu 100%
Percentage variation in quantity to be allowed while receiving or delivering this item.,"Variație procentuală, în cantitate va fi permisă în timp ce primirea sau livrarea acestui articol."
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.,"Procentul vi se permite de a primi sau livra mai mult față de cantitatea comandata. De exemplu: Dacă ați comandat 100 de unități. și alocația este de 10%, atunci vi se permite să primească 110 de unități."
Performance appraisal.,De evaluare a performanțelor.
Period,Perioada
Period Closing Voucher,Voucher perioadă de închidere
Periodicity,Periodicitate
Permanent Address,Permanent Adresa
Permanent Address Is,Adresa permanentă este
Permission,Permisiune
Personal,Trader
Personal Details,Detalii personale
Personal Email,Personal de e-mail
Pharmaceutical,Farmaceutic
Pharmaceuticals,Produse farmaceutice
Phone,Telefon
Phone No,Nu telefon
Piecework,Muncă în acord
Pincode,Parola așa
Place of Issue,Locul eliberării
Plan for maintenance visits.,Planul de de vizite de întreținere.
Planned Qty,Planificate Cantitate
"Planned Qty: Quantity, for which, Production Order has been raised, but is pending to be manufactured.","Planificate Cantitate: Cantitate, pentru care, de producție Ordinul a fost ridicat, dar este în curs de a fi fabricate."
Planned Quantity,Planificate Cantitate
Planning,Planificare
Plant,Instalarea
Plant and Machinery,Instalații tehnice și mașini
Please Enter Abbreviation or Short Name properly as it will be added as Suffix to all Account Heads.,Vă rugăm Introduceți abreviere sau Numele Scurt corect ca acesta va fi adăugat ca sufix la toate capetele de cont.
Please Update SMS Settings,Vă rugăm să actualizați Setări SMS
Please add expense voucher details,Vă rugăm să adăugați cheltuieli detalii voucher
Please add to Modes of Payment from Setup.,Vă rugăm să adăugați la Moduri de plată de la instalare.
Please check 'Is Advance' against Account {0} if this is an advance entry.,"Vă rugăm să verificați ""Este Advance"" împotriva Contul {0} în cazul în care acest lucru este o intrare în avans."
Please click on 'Generate Schedule',"Vă rugăm să faceți clic pe ""Generate Program"""
Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Vă rugăm să faceți clic pe ""Generate Program"", pentru a aduce ordine adăugat pentru postul {0}"
Please click on 'Generate Schedule' to get schedule,"Vă rugăm să faceți clic pe ""Generate Program"", pentru a obține programul"
Please create Customer from Lead {0},Vă rugăm să creați client de plumb {0}
Please create Salary Structure for employee {0},Vă rugăm să creați Structura Salariul pentru angajat {0}
Please create new account from Chart of Accounts.,Vă rugăm să creați un cont nou de Planul de conturi.
Please do NOT create Account (Ledgers) for Customers and Suppliers. They are created directly from the Customer / Supplier masters.,Vă rugăm să nu crea contul (Ledgers) pentru clienții și furnizorii. Ele sunt create direct de la masterat client / furnizor.
Please enter 'Expected Delivery Date',"Vă rugăm să introduceți ""Data de livrare așteptată"""
Please enter 'Is Subcontracted' as Yes or No,"Va rugam sa introduceti ""este subcontractată"" ca Da sau Nu"
Please enter 'Repeat on Day of Month' field value,"Va rugam sa introduceti ""Repeat la zi a lunii"" valoare de câmp"
Please enter Account Receivable/Payable group in company master,Va rugam sa introduceti cont de încasat / de grup se plateste in companie de master
Please enter Approving Role or Approving User,Va rugam sa introduceti Aprobarea Rolul sau aprobarea de utilizare
Please enter BOM for Item {0} at row {1},Va rugam sa introduceti BOM pentru postul {0} la rândul {1}
Please enter Company,Va rugam sa introduceti de companie
Please enter Cost Center,Va rugam sa introduceti Cost Center
Please enter Delivery Note No or Sales Invoice No to proceed,Va rugam sa introduceti de livrare Notă Nu sau Factura Vanzare Nu pentru a continua
Please enter Employee Id of this sales parson,Vă rugăm să introduceți ID-ul angajatului din acest Parson vânzări
Please enter Expense Account,Va rugam sa introduceti cont de cheltuieli
Please enter Item Code to get batch no,Va rugam sa introduceti codul articol pentru a obține lot nu
Please enter Item Code.,Vă rugăm să introduceți Cod produs.
Please enter Item first,Va rugam sa introduceti Articol primul
Please enter Maintaince Details first,Va rugam sa introduceti maintaince detaliile prima
Please enter Master Name once the account is created.,Va rugam sa introduceti Maestrul Numele odată ce este creat contul.
Please enter Planned Qty for Item {0} at row {1},Va rugam sa introduceti planificate Cantitate pentru postul {0} la rândul {1}
Please enter Production Item first,Va rugam sa introduceti de producție Articol întâi
Please enter Purchase Receipt No to proceed,Va rugam sa introduceti Primirea de cumparare Nu pentru a continua
Please enter Reference date,Vă rugăm să introduceți data de referință
Please enter Warehouse for which Material Request will be raised,Va rugam sa introduceti Depozit pentru care va fi ridicat Material Cerere
Please enter Write Off Account,Va rugam sa introduceti Scrie Off cont
Please enter atleast 1 invoice in the table,Va rugam sa introduceti cel putin 1 factura în tabelul
Please enter company first,Va rugam sa introduceti prima companie
Please enter company name first,Va rugam sa introduceti numele companiei în primul rând
Please enter default Unit of Measure,Va rugam sa introduceti Unitatea de măsură prestabilită
Please enter default currency in Company Master,Va rugam sa introduceti moneda implicit în Compania de Master
Please enter email address,Introduceți adresa de e-mail
Please enter item details,Va rugam sa introduceti detalii element
Please enter message before sending,Vă rugăm să introduceți mesajul înainte de trimitere
Please enter parent account group for warehouse account,Va rugam sa introduceti grup considerare părinte de cont depozit
Please enter parent cost center,Vă rugăm să introduceți centru de cost părinte
Please enter quantity for Item {0},Va rugam sa introduceti cantitatea pentru postul {0}
Please enter relieving date.,Vă rugăm să introduceți data alinarea.
Please enter sales order in the above table,Vă rugăm să introduceți comenzi de vânzări în tabelul de mai sus
Please enter valid Company Email,Va rugam sa introduceti email valida de companie
Please enter valid Email Id,Va rugam sa introduceti email valida Id
Please enter valid Personal Email,Va rugam sa introduceti email valida personale
Please enter valid mobile nos,Va rugam sa introduceti nos mobile valabile
Please find attached Sales Invoice #{0},Vă rugăm să găsiți atașat Factura Vanzare # {0}
Please install dropbox python module,Vă rugăm să instalați dropbox modul python
Please mention no of visits required,Vă rugăm să menționați nici de vizite necesare
Please pull items from Delivery Note,Vă rugăm să trage elemente de livrare Nota
Please save the Newsletter before sending,Vă rugăm să salvați Newsletter înainte de a trimite
Please save the document before generating maintenance schedule,Vă rugăm să salvați documentul înainte de a genera programul de întreținere
Please see attachment,Vă rugăm să consultați atașament
Please select Bank Account,Vă rugăm să selectați cont bancar
Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,Vă rugăm să selectați reporta dacă doriți și să includă echilibrul de anul precedent fiscal lasă în acest an fiscal
Please select Category first,Vă rugăm să selectați categoria întâi
Please select Charge Type first,Vă rugăm să selectați de încărcare Tip întâi
Please select Fiscal Year,Vă rugăm să selectați Anul fiscal
Please select Group or Ledger value,Vă rugăm să selectați Group sau Ledger valoare
Please select Incharge Person's name,Vă rugăm să selectați numele Incharge Persoana
Please select Invoice Type and Invoice Number in atleast one row,Vă rugăm să selectați Factura Tip și factura Numărul din cel putin un rând
"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Sales BOM","Vă rugăm să selectați element, de unde ""Este Piesa"" este ""Nu"" și ""E Articol de vânzări"" este ""da"", și nu există nici un alt Vanzari BOM"
Please select Price List,Vă rugăm să selectați lista de prețuri
Please select Start Date and End Date for Item {0},Vă rugăm să selectați data de început și Data de final pentru postul {0}
Please select Time Logs.,Vă rugăm să selectați Ora Activitate.
Please select a csv file,Vă rugăm să selectați un fișier csv
Please select a valid csv file with data,Vă rugăm să selectați un fișier csv valid cu date
Please select a value for {0} quotation_to {1},Vă rugăm să selectați o valoare de {0} {1} quotation_to
"Please select an ""Image"" first","Vă rugăm să selectați o ""imagine"" în primul rând"
Please select charge type first,Vă rugăm să selectați tipul de taxă în primul rând
Please select company first,Vă rugăm să selectați prima companie
Please select company first.,Vă rugăm să selectați prima companie.
Please select item code,Vă rugăm să selectați codul de articol
Please select month and year,Vă rugăm selectați luna și anul
Please select prefix first,Vă rugăm să selectați prefix întâi
Please select the document type first,Vă rugăm să selectați tipul de document primul
Please select weekly off day,Vă rugăm să selectați zi liberă pe săptămână
Please select {0},Vă rugăm să selectați {0}
Please select {0} first,Vă rugăm să selectați {0} primul
Please select {0} first.,Vă rugăm să selectați {0} primul.
Please set Dropbox access keys in your site config,Vă rugăm să setați tastele de acces Dropbox pe site-ul dvs. de configurare
Please set Google Drive access keys in {0},Vă rugăm să setați tastele de acces disk Google în {0}
Please set default Cash or Bank account in Mode of Payment {0},Vă rugăm să setați Cash implicit sau cont bancar în modul de plată {0}
Please set default value {0} in Company {0},Vă rugăm să setați valoarea implicită {0} în companie {0}
Please set {0},Vă rugăm să setați {0}
Please setup Employee Naming System in Human Resource > HR Settings,Vă rugăm să configurare Angajat sistemul de numire în resurse umane> Settings HR
Please setup numbering series for Attendance via Setup > Numbering Series,Vă rugăm să configurare serie de numerotare pentru Spectatori prin Setup> Numerotare Series
Please setup your chart of accounts before you start Accounting Entries,Vă rugăm configurarea diagrama de conturi înainte de a începe înregistrările contabile
Please specify,Vă rugăm să specificați
Please specify Company,Vă rugăm să specificați companiei
Please specify Company to proceed,Vă rugăm să specificați companiei pentru a continua
Please specify Default Currency in Company Master and Global Defaults,Vă rugăm să specificați Monedă implicită în Compania de Master și setări implicite globale
Please specify a,Vă rugăm să specificați un
Please specify a valid 'From Case No.',"Vă rugăm să specificați un valabil ""Din cauza nr"""
Please specify a valid Row ID for {0} in row {1},Vă rugăm să specificați un ID valid de linie pentru {0} în rândul {1}
Please specify either Quantity or Valuation Rate or both,Vă rugăm să specificați fie Cantitate sau Evaluează evaluare sau ambele
Please submit to update Leave Balance.,Vă rugăm să trimiteți actualizarea concediul Balance.
Plot,Parcelarea / Reprezentarea grafică / Trasarea
Plot By,Plot Prin
Point of Sale,Point of Sale
Point-of-Sale Setting,Punct-de-vânzare Setting
Post Graduate,Postuniversitar
Postal,Poștal
Postal Expenses,Cheltuieli poștale
Posting Date,Dată postare
Posting Time,Postarea de timp
Posting date and posting time is mandatory,Data postării și postarea de timp este obligatorie
Posting timestamp must be after {0},Timestamp postarea trebuie să fie după {0}
Potential opportunities for selling.,Potențiale oportunități de vânzare.
Preferred Billing Address,Adresa de facturare preferat
Preferred Shipping Address,Preferat Adresa Shipping
Prefix,Prefix
Present,Prezenta
Prevdoc DocType,Prevdoc DocType
Prevdoc Doctype,Prevdoc Doctype
Preview,Previzualizați
Previous,Precedenta
Previous Work Experience,Anterior Work Experience
Price,Preț
Price / Discount,Preț / Reducere
Price List,Lista de prețuri
Price List Currency,Lista de pret Valuta
Price List Currency not selected,Lista de pret Valuta nu selectat
Price List Exchange Rate,Lista de prețuri Cursul de schimb
Price List Name,Lista de preț Nume
Price List Rate,Lista de prețuri Rate
Price List Rate (Company Currency),Lista de prețuri Rate (Compania de valuta)
Price List master.,Maestru Lista de prețuri.
Price List must be applicable for Buying or Selling,Lista de prețuri trebuie să fie aplicabilă pentru cumpărarea sau vânzarea de
Price List not selected,Lista de prețuri nu selectat
Price List {0} is disabled,Lista de prețuri {0} este dezactivat
Price or Discount,Preț sau Reducere
Pricing Rule,Regula de stabilire a prețurilor
Pricing Rule Help,Regula de stabilire a prețurilor de ajutor
"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Regula de stabilire a prețurilor este selectat în primul rând bazat pe ""Aplicați pe"" teren, care poate fi produs, Grupa de articole sau de brand."
"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Regula de stabilire a prețurilor se face pentru a suprascrie Pret / defini procent de reducere, pe baza unor criterii."
Pricing Rules are further filtered based on quantity.,Regulile de stabilire a prețurilor sunt filtrate în continuare în funcție de cantitate.
Print Format Style,Print Style Format
Print Heading,Imprimare Titlu
Print Without Amount,Imprima Fără Suma
Print and Stationary,Imprimare și staționare
Printing and Branding,Imprimarea și Branding
Priority,Prioritate
Private Equity,Private Equity
Privilege Leave,Privilege concediu
Probation,Probă
Process Payroll,Salarizare proces
Produced,Produs
Produced Quantity,Produs Cantitate
Product Enquiry,Intrebare produs
Production,Producţie
Production Order,Număr Comandă Producţie:
Production Order status is {0},Statutul de producție Ordinul este {0}
Production Order {0} must be cancelled before cancelling this Sales Order,Producția de Ordine {0} trebuie anulată înainte de a anula această comandă de vânzări
Production Order {0} must be submitted,Producția de Ordine {0} trebuie să fie prezentate
Production Orders,Comenzi de producție
Production Orders in Progress,Comenzile de producție în curs de desfășurare
Production Plan Item,Planul de producție Articol
Production Plan Items,Planul de producție Articole
Production Plan Sales Order,Planul de producție comandă de vânzări
Production Plan Sales Orders,Planul de producție comenzi de vânzări
Production Planning Tool,Producție instrument de planificare
Products,Instrumente
"Products will be sorted by weight-age in default searches. More the weight-age, higher the product will appear in the list.","Produsele vor fi clasificate în funcție de greutate, vârstă în căutări implicite. Mai mult greutate de vârstă, mai mare produsul va apărea în listă."
Professional Tax,Taxa profesional
Profit and Loss,Profit și pierdere
Profit and Loss Statement,Profit și pierdere
Project,Proiectarea
Project Costing,Proiect de calculație a costurilor
Project Details,Detalii proiect
Project Manager,Manager de Proiect
Project Milestone,Milestone proiect
Project Milestones,Repere de proiect
Project Name,Denumirea proiectului
Project Start Date,Data de începere a proiectului
Project Type,Tip de proiect
Project Value,Valoare proiect
Project activity / task.,Activitatea de proiect / sarcină.
Project master.,Maestru proiect.
Project will get saved and will be searchable with project name given,Proiect vor fi salvate și vor fi căutate cu nume proiect dat
Project wise Stock Tracking,Proiect înțelept Tracking Stock
Project-wise data is not available for Quotation,Date proiect-înțelept nu este disponibilă pentru ofertă
Projected,Proiectat
Projected Qty,Proiectat Cantitate
Projects,Proiecte
Projects & System,Proiecte & System
Prompt for Email on Submission of,Prompt de e-mail pe Depunerea
Proposal Writing,Propunere de scriere
Provide email id registered in company,Furnizarea id-ul de e-mail înregistrată în societate
Provisional Profit / Loss (Credit),Profit provizorie / Pierdere (Credit)
Public,Public
Published on website at: {0},Publicat pe site-ul la: {0}
Publishing,Editare
Pull sales orders (pending to deliver) based on the above criteria,"Trage comenzi de vânzări (în curs de a livra), pe baza criteriilor de mai sus"
Purchase,Cumpărarea
Purchase / Manufacture Details,Detalii de cumpărare / Fabricarea
Purchase Analytics,Analytics de cumpărare
Purchase Common,Cumpărare comună
Purchase Details,Detalii de cumpărare
Purchase Discounts,Cumpărare Reduceri
Purchase Invoice,Factura de cumpărare
Purchase Invoice Advance,Factura de cumpărare în avans
Purchase Invoice Advances,Avansuri factura de cumpărare
Purchase Invoice Item,Factura de cumpărare Postul
Purchase Invoice Trends,Cumpărare Tendințe factură
Purchase Invoice {0} is already submitted,Factura de cumpărare {0} este deja depusă
Purchase Order,Comandă de aprovizionare
Purchase Order Item,Comandă de aprovizionare Articol
Purchase Order Item No,Comandă de aprovizionare Punctul nr
Purchase Order Item Supplied,Comandă de aprovizionare Articol Livrat
Purchase Order Items,Cumpărare Ordine Articole
Purchase Order Items Supplied,Comandă de aprovizionare accesoriilor furnizate
Purchase Order Items To Be Billed,Cumparare Ordine Articole Pentru a fi facturat
Purchase Order Items To Be Received,Achiziția comandă elementele de încasat
Purchase Order Message,Purchase Order Mesaj
Purchase Order Required,Comandă de aprovizionare necesare
Purchase Order Trends,Comandă de aprovizionare Tendințe
Purchase Order number required for Item {0},Număr de comandă de aprovizionare necesare pentru postul {0}
Purchase Order {0} is 'Stopped',"Achiziția comandă {0} este ""Oprit"""
Purchase Order {0} is not submitted,Comandă {0} nu este prezentat
Purchase Orders given to Suppliers.,A achiziționa ordine de date Furnizori.
Purchase Receipt,Primirea de cumpărare
Purchase Receipt Item,Primirea de cumpărare Postul
Purchase Receipt Item Supplied,Primirea de cumpărare Articol Livrat
Purchase Receipt Item Supplieds,Primirea de cumpărare Supplieds Postul
Purchase Receipt Items,Primirea de cumpărare Articole
Purchase Receipt Message,Primirea de cumpărare Mesaj
Purchase Receipt No,Primirea de cumpărare Nu
Purchase Receipt Required,Cumpărare de primire Obligatoriu
Purchase Receipt Trends,Tendințe Primirea de cumpărare
Purchase Receipt number required for Item {0},Număr Primirea de achiziție necesar pentru postul {0}
Purchase Receipt {0} is not submitted,Primirea de cumpărare {0} nu este prezentat
Purchase Register,Cumpărare Inregistrare
Purchase Return,Înapoi cumpărare
Purchase Returned,Cumpărare returnate
Purchase Taxes and Charges,Taxele de cumpărare și Taxe
Purchase Taxes and Charges Master,Taxele de cumpărare și taxe de Master
Purchse Order number required for Item {0},Număr de ordine Purchse necesar pentru postul {0}
Purpose,Scopul
Purpose must be one of {0},Scopul trebuie să fie una dintre {0}
QA Inspection,QA Inspecția
Qty,Cantitate
Qty Consumed Per Unit,Cantitate consumata pe unitatea
Qty To Manufacture,Cantitate pentru fabricarea
Qty as per Stock UOM,Cantitate conform Stock UOM
Qty to Deliver,Cantitate pentru a oferi
Qty to Order,Cantitate pentru comandă
Qty to Receive,Cantitate de a primi
Qty to Transfer,Cantitate de a transfera
Qualification,Calificare
Quality,Calitate
Quality Inspection,Inspecție de calitate
Quality Inspection Parameters,Parametrii de control de calitate
Quality Inspection Reading,Inspecție de calitate Reading
Quality Inspection Readings,Lecturi de control de calitate
Quality Inspection required for Item {0},Inspecție de calitate necesare pentru postul {0}
Quality Management,Managementul calitatii
Quantity,Cantitate
Quantity Requested for Purchase,Cantitate solicitată de cumparare
Quantity and Rate,Cantitatea și rata
Quantity and Warehouse,Cantitatea și Warehouse
Quantity cannot be a fraction in row {0},Cantitatea nu poate fi o fracțiune în rând {0}
Quantity for Item {0} must be less than {1},Cantitatea pentru postul {0} trebuie să fie mai mică de {1}
Quantity in row {0} ({1}) must be same as manufactured quantity {2},"Cantitatea în rândul {0} ({1}), trebuie să fie aceeași ca și cantitatea produsă {2}"
Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Cantitatea de produs obținut după fabricarea / reambalare de la cantități date de materii prime
Quantity required for Item {0} in row {1},Cantitatea necesară pentru postul {0} în rândul {1}
Quarter,Trimestru
Quarterly,Trimestrial
Quick Help,Ajutor rapid
Quotation,Citat
Quotation Item,Citat Articol
Quotation Items,Cotație Articole
Quotation Lost Reason,Citat pierdut rațiunea
Quotation Message,Citat Mesaj
Quotation To,Citat Pentru a
Quotation Trends,Cotație Tendințe
Quotation {0} is cancelled,Citat {0} este anulat
Quotation {0} not of type {1},Citat {0} nu de tip {1}
Quotations received from Suppliers.,Cotatiilor primite de la furnizori.
Quotes to Leads or Customers.,Citate la Oportunitati sau clienți.
Raise Material Request when stock reaches re-order level,Ridica Material Cerere atunci când stocul ajunge la nivelul re-comandă
Raised By,Ridicate de
Raised By (Email),Ridicate de (e-mail)
Random,Aleatorii
Range,Interval
Rate,rată
Rate ,
Rate (%),Rate (%)
Rate (Company Currency),Rata de (Compania de valuta)
Rate Of Materials Based On,Rate de materiale bazate pe
Rate and Amount,Rata și volumul
Rate at which Customer Currency is converted to customer's base currency,Rata la care Clientul valuta este convertită în valuta de bază a clientului
Rate at which Price list currency is converted to company's base currency,Rata la care lista de prețuri moneda este convertit în moneda de bază a companiei
Rate at which Price list currency is converted to customer's base currency,Rata la care lista de prețuri moneda este convertit în valuta de bază a clientului
Rate at which customer's currency is converted to company's base currency,Rata la care moneda clientului este convertită în valuta de bază a companiei
Rate at which supplier's currency is converted to company's base currency,Rata la care moneda furnizorului este convertit în moneda de bază a companiei
Rate at which this tax is applied,Rata la care se aplică acest impozit
Raw Material,Material brut
Raw Material Item Code,Material brut Articol Cod
Raw Materials Supplied,Materii prime furnizate
Raw Materials Supplied Cost,Costul materiilor prime livrate
Raw material cannot be same as main Item,Materii prime nu poate fi la fel ca Item principal
Re-Order Level,Re-Order de nivel
Re-Order Qty,Re-Order Cantitate
Re-order,Re-comandă
Re-order Level,Nivelul de re-comandă
Re-order Qty,Re-comanda Cantitate
Read,Citirea
Reading 1,Reading 1
Reading 10,Reading 10
Reading 2,Reading 2
Reading 3,Reading 3
Reading 4,Reading 4
Reading 5,Lectură 5
Reading 6,Reading 6
Reading 7,Lectură 7
Reading 8,Lectură 8
Reading 9,Lectură 9
Real Estate,Imobiliare
Reason,motiv
Reason for Leaving,Motiv pentru Lăsând
Reason for Resignation,Motiv pentru demisie
Reason for losing,Motiv pentru a pierde
Recd Quantity,Recd Cantitate
Receivable,De încasat
Receivable / Payable account will be identified based on the field Master Type,De încasat de cont / de plătit vor fi identificate pe baza teren de Master Tip
Receivables,Creanțe
Receivables / Payables,Creanțe / Datorii
Receivables Group,Creanțe Group
Received Date,Data primit
Received Items To Be Billed,Articole primite Pentru a fi facturat
Received Qty,Primit Cantitate
Received and Accepted,Primite și acceptate
Receiver List,Receptor Lista
Receiver List is empty. Please create Receiver List,Receptor Lista goala. Vă rugăm să creați Receiver Lista
Receiver Parameter,Receptor Parametru
Recipients,Destinatarii
Reconcile,Reconcilierea
Reconciliation Data,Reconciliere a datelor
Reconciliation HTML,Reconciliere HTML
Reconciliation JSON,Reconciliere JSON
Record item movement.,Mișcare element înregistrare.
Recurring Id,Recurent Id
Recurring Invoice,Factura recurent
Recurring Type,Tip recurent
Reduce Deduction for Leave Without Pay (LWP),Reduce Deducerea pentru concediu fără plată (LWP)
Reduce Earning for Leave Without Pay (LWP),Reduce Câștigul salarial de concediu fără plată (LWP)
Ref,Re
Ref Code,Cod de Ref
Ref SQ,Ref SQ
Reference,Referinta
Reference #{0} dated {1},Reference # {0} din {1}
Reference Date,Data de referință
Reference Name,Nume de referință
Reference No & Reference Date is required for {0},Nu referință și de referință Data este necesar pentru {0}
Reference No is mandatory if you entered Reference Date,De referință nu este obligatorie în cazul în care ați introdus Reference Data
Reference Number,Numărul de referință
Reference Row #,Reference Row #
Refresh,Actualizare
Registration Details,Detalii de înregistrare
Registration Info,Înregistrare Info
Rejected,Respinse
Rejected Quantity,Respins Cantitate
Rejected Serial No,Respins de ordine
Rejected Warehouse,Depozit Respins
Rejected Warehouse is mandatory against regected item,Warehouse respins este obligatorie împotriva articol regected
Relation,Relație
Relieving Date,Alinarea Data
Relieving Date must be greater than Date of Joining,Alinarea Data trebuie să fie mai mare decât Data aderării
Remark,Remarcă
Remarks,Remarci
Remarks Custom,Observații personalizat
Rename,Redenumire
Rename Log,Redenumi Conectare
Rename Tool,Redenumirea Tool
Rent Cost,Chirie Cost
Rent per hour,Inchirieri pe oră
Rented,Închiriate
Repeat on Day of Month,Repetați în ziua de Luna
Replace,Înlocuirea
Replace Item / BOM in all BOMs,Înlocuiți Articol / BOM în toate extraselor
Replied,A răspuns:
Report Date,Data raportului
Report Type,Tip de raport
Report Type is mandatory,Tip de raport este obligatorie
Reports to,Rapoarte
Reqd By Date,Reqd de Date
Reqd by Date,Reqd de Date
Request Type,Cerere tip
Request for Information,Cerere de informații
Request for purchase.,Cere pentru cumpărare.
Requested,Solicitată
Requested For,Pentru a solicitat
Requested Items To Be Ordered,Elemente solicitate să fie comandate
Requested Items To Be Transferred,Elemente solicitate să fie transferată
Requested Qty,A solicitat Cantitate
"Requested Qty: Quantity requested for purchase, but not ordered.","A solicitat Cantitate: Cantitatea solicitate pentru achiziții, dar nu a ordonat."
Requests for items.,Cererile de elemente.
Required By,Cerute de
Required Date,Date necesare
Required Qty,Necesar Cantitate
Required only for sample item.,Necesar numai pentru element de probă.
Required raw materials issued to the supplier for producing a sub - contracted item.,Materii prime necesare emise de furnizor pentru producerea unui sub - element contractat.
Research,Cercetarea
Research & Development,Cercetare & Dezvoltare
Researcher,Cercetător
Reseller,Reseller
Reserved,Rezervat
Reserved Qty,Rezervate Cantitate
"Reserved Qty: Quantity ordered for sale, but not delivered.","Rezervate Cantitate: Cantitatea comandat de vânzare, dar nu livrat."
Reserved Quantity,Rezervat Cantitate
Reserved Warehouse,Rezervat Warehouse
Reserved Warehouse in Sales Order / Finished Goods Warehouse,Rezervat Warehouse în Vânzări Ordine / Produse finite Warehouse
Reserved Warehouse is missing in Sales Order,Rezervat Warehouse lipsește în comandă de vânzări
Reserved Warehouse required for stock Item {0} in row {1},Depozit rezervat necesar pentru stocul de postul {0} în rândul {1}
Reserved warehouse required for stock item {0},Depozit rezervat necesar pentru postul de valori {0}
Reserves and Surplus,Rezerve și Excedent
Reset Filters,Reset Filtre
Resignation Letter Date,Scrisoare de demisie Data
Resolution,Rezolutie
Resolution Date,Data rezoluție
Resolution Details,Rezoluția Detalii
Resolved By,Rezolvat prin
Rest Of The World,Restul lumii
Retail,Cu amănuntul
Retail & Wholesale,Retail & Wholesale
Retailer,Vânzător cu amănuntul
Review Date,Data Comentariului
Rgt,RGT
Role Allowed to edit frozen stock,Rol permise pentru a edita stoc congelate
Role that is allowed to submit transactions that exceed credit limits set.,Rol care i se permite să prezinte tranzacțiile care depășesc limitele de credit stabilite.
Root Type,Rădăcină Tip
Root Type is mandatory,Rădăcină de tip este obligatorie
Root account can not be deleted,Contul de root nu pot fi șterse
Root cannot be edited.,Rădăcină nu poate fi editat.
Root cannot have a parent cost center,Rădăcină nu poate avea un centru de cost părinte
Rounded Off,Rotunjite
Rounded Total,Rotunjite total
Rounded Total (Company Currency),Rotunjite total (Compania de valuta)
Row # ,
Row # {0}: ,
Row #{0}: Ordered qty can not less than item's minimum order qty (defined in item master).,Rând # {0}: Cantitate Comandat poate nu mai puțin de cantitate minimă de comandă item (definit la punctul de master).
Row #{0}: Please specify Serial No for Item {1},Rând # {0}: Vă rugăm să specificați Nu serial pentru postul {1}
"Row {0}: Account does not match with \
						Purchase Invoice Credit To account","Rând {0}: Contul nu se potrivește cu \
 cumparare Facturi de credit a contului"
"Row {0}: Account does not match with \
						Sales Invoice Debit To account","Rând {0}: Contul nu se potrivește cu \
 Vânzări Facturi de debit a contului"
Row {0}: Conversion Factor is mandatory,Rând {0}: Factorul de conversie este obligatorie
Row {0}: Credit entry can not be linked with a Purchase Invoice,Rând {0}: intrare de credit nu poate fi legat cu o factura de cumpărare
Row {0}: Debit entry can not be linked with a Sales Invoice,Rând {0}: intrare de debit nu poate fi legat de o factură de vânzare
Row {0}: Payment amount must be less than or equals to invoice outstanding amount. Please refer Note below.,Rând {0}: Suma de plată trebuie să fie mai mic sau egal cu factura suma restante. Vă rugăm să consultați nota de mai jos.
Row {0}: Qty is mandatory,Rând {0}: Cant este obligatorie
"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.
					Available Qty: {4}, Transfer Qty: {5}","Rând {0}: Cantitate nu avalable în depozit {1} la {2} {3}.
 Disponibil Cantitate: {4}, transfer Cantitate: {5}"
"Row {0}: To set {1} periodicity, difference between from and to date \
						must be greater than or equal to {2}","Rând {0}: Pentru a seta {1} periodicitate, diferența între de la și până la data \
 trebuie să fie mai mare sau egal cu {2}"
Row {0}:Start Date must be before End Date,Rând {0}: Data începerii trebuie să fie înainte de Data de încheiere
Rules for adding shipping costs.,Reguli pentru a adăuga costurile de transport maritim.
Rules for applying pricing and discount.,Normele de aplicare de stabilire a prețurilor și de scont.
Rules to calculate shipping amount for a sale,Reguli pentru a calcula suma de transport maritim pentru o vânzare
S.O. No.,SO Nu.
SHE Cess on Excise,SHE Cess pe accize
SHE Cess on Service Tax,SHE Cess la Serviciul Fiscal
SHE Cess on TDS,SHE Cess pe TDS
SMS Center,SMS Center
SMS Gateway URL,SMS Gateway URL
SMS Log,SMS Conectare
SMS Parameter,SMS Parametru
SMS Sender Name,SMS Sender Name
SMS Settings,Setări SMS
SO Date,SO Data
SO Pending Qty,SO așteptare Cantitate
SO Qty,SO Cantitate
Salary,Salariu
Salary Information,Informațiile de salarizare
Salary Manager,Salariul Director
Salary Mode,Mod de salariu
Salary Slip,Salariul Slip
Salary Slip Deduction,Salariul Slip Deducerea
Salary Slip Earning,Salariul Slip Câștigul salarial
Salary Slip of employee {0} already created for this month,Salariul alunecare de angajat {0} deja creat pentru această lună
Salary Structure,Structura salariu
Salary Structure Deduction,Structura Salariul Deducerea
Salary Structure Earning,Structura salariu Câștigul salarial
Salary Structure Earnings,Câștiguri Structura salariu
Salary breakup based on Earning and Deduction.,Salariul despartire bazat privind câștigul salarial și deducere.
Salary components.,Componente salariale.
Salary template master.,Maestru șablon salariu.
Sales,Vanzari
Sales Analytics,Analytics de vânzare
Sales BOM,Vânzări BOM
Sales BOM Help,Vânzări BOM Ajutor
Sales BOM Item,Vânzări BOM Articol
Sales BOM Items,Vânzări BOM Articole
Sales Browser,Vânzări Browser
Sales Details,Detalii de vanzari
Sales Discounts,Reduceri de vânzare
Sales Email Settings,Setări de vânzări de e-mail
Sales Expenses,Cheltuieli de vânzare
Sales Extras,Extras de vânzare
Sales Funnel,De vânzări pâlnie
Sales Invoice,Factură de vânzări
Sales Invoice Advance,Factura Vanzare Advance
Sales Invoice Item,Factură de vânzări Postul
Sales Invoice Items,Factura de vânzare Articole
Sales Invoice Message,Factură de vânzări Mesaj
Sales Invoice No,Factură de vânzări Nu
Sales Invoice Trends,Vânzări Tendințe factură
Sales Invoice {0} has already been submitted,Factură de vânzări {0} a fost deja prezentat
Sales Invoice {0} must be cancelled before cancelling this Sales Order,Factură de vânzări {0} trebuie anulată înainte de a anula această comandă de vânzări
Sales Order,Comandă de vânzări
Sales Order Date,Comandă de vânzări Data
Sales Order Item,Comandă de vânzări Postul
Sales Order Items,Vânzări Ordine Articole
Sales Order Message,Comandă de vânzări Mesaj
Sales Order No,Vânzări Ordinul nr
Sales Order Required,Comandă de vânzări obligatorii
Sales Order Trends,Vânzări Ordine Tendințe
Sales Order required for Item {0},Ordinul de vânzări necesar pentru postul {0}
Sales Order {0} is not submitted,Comandă de vânzări {0} nu este prezentat
Sales Order {0} is not valid,Comandă de vânzări {0} nu este valid
Sales Order {0} is stopped,Comandă de vânzări {0} este oprit
Sales Partner,Partener de vânzări
Sales Partner Name,Numele Partner Sales
Sales Partner Target,Vânzări Partner țintă
Sales Partners Commission,Agent vânzări al Comisiei
Sales Person,Persoana de vânzări
Sales Person Name,Sales Person Nume
Sales Person Target Variance Item Group-Wise,Persoana de vânzări țintă varianță Articol Grupa Înțelept
Sales Person Targets,Obiective de vânzări Persoana
Sales Person-wise Transaction Summary,Persoana de vânzări-înțelept Rezumat Transaction
Sales Register,Vânzări Inregistrare
Sales Return,Vânzări de returnare
Sales Returned,Vânzări întors
Sales Taxes and Charges,Taxele de vânzări și Taxe
Sales Taxes and Charges Master,Taxele de vânzări și taxe de Master
Sales Team,Echipa de vânzări
Sales Team Details,Detalii de vânzări Echipa
Sales Team1,Vânzări TEAM1
Sales and Purchase,Vanzari si cumparare
Sales campaigns.,Campanii de vanzari.
Salutation,Salut
Sample Size,Eșantionul de dimensiune
Sanctioned Amount,Sancționate Suma
Saturday,Sâmbătă
Schedule,Program
Schedule Date,Program Data
Schedule Details,Detalii Program
Scheduled,Programat
Scheduled Date,Data programată
Scheduled to send to {0},Programat pentru a trimite la {0}
Scheduled to send to {0} recipients,Programat pentru a trimite la {0} destinatari
Scheduler Failed Events,Evenimente planificator nereușite
School/University,Școlar / universitar
Score (0-5),Scor (0-5)
Score Earned,Scor Earned
Score must be less than or equal to 5,Scorul trebuie să fie mai mică sau egală cu 5
Scrap %,Resturi%
Seasonality for setting budgets.,Sezonier pentru stabilirea bugetelor.
Secretary,Secretar
Secured Loans,Împrumuturi garantate
Securities & Commodity Exchanges,A Valorilor Mobiliare și Burselor de Mărfuri
Securities and Deposits,Titluri de valoare și depozite
"See ""Rate Of Materials Based On"" in Costing Section","A se vedea ""Rate de materiale bazate pe"" în Costing Secțiunea"
"Select ""Yes"" for sub - contracting items","Selectați ""Da"" de sub - produse contractantă"
"Select ""Yes"" if this item is used for some internal purpose in your company.","Selectați ""Da"" în cazul în care acest element este folosit pentru un scop intern în compania dumneavoastră."
"Select ""Yes"" if this item represents some work like training, designing, consulting etc.","Selectați ""Da"" în cazul în care acest articol reprezintă ceva de lucru cum ar fi formarea, proiectare, consultanta etc"
"Select ""Yes"" if you are maintaining stock of this item in your Inventory.","Selectați ""Da"", dacă sunteți menținerea stocului de acest element în inventar."
"Select ""Yes"" if you supply raw materials to your supplier to manufacture this item.","Selectați ""Da"", dacă aprovizionarea cu materii prime a furnizorului dumneavoastră pentru a fabrica acest articol."
Select Brand...,Selectați Brand ...
Select Budget Distribution to unevenly distribute targets across months.,Selectați Bugetul de distribuție pentru a distribui uniform obiective pe luni.
"Select Budget Distribution, if you want to track based on seasonality.","Selectați Buget Distribution, dacă doriți să urmăriți în funcție de sezonalitate."
Select Company...,Selectați Company ...
Select DocType,Selectați DocType
Select Fiscal Year...,Selectați anul fiscal ...
Select Items,Selectați Elemente
Select Project...,Selectați Project ...
Select Purchase Receipts,Selectați Încasări de cumpărare
Select Sales Orders,Selectați comenzi de vânzări
Select Sales Orders from which you want to create Production Orders.,Selectați comenzi de vânzări de la care doriți să creați comenzi de producție.
Select Time Logs and Submit to create a new Sales Invoice.,Selectați Timp Busteni Trimite pentru a crea o nouă factură de vânzare.
Select Transaction,Selectați Transaction
Select Warehouse...,Selectați Warehouse ...
Select Your Language,Selectați limba
Select account head of the bank where cheque was deposited.,"Selectați contul șef al băncii, unde de verificare a fost depus."
Select company name first.,Selectați numele companiei în primul rând.
Select template from which you want to get the Goals,Selectați șablonul din care doriți să obțineți Obiectivelor
Select the Employee for whom you are creating the Appraisal.,Selectați angajatul pentru care doriți să creați de evaluare.
Select the period when the invoice will be generated automatically,Selectați perioada în care factura va fi generat automat
Select the relevant company name if you have multiple companies,"Selectați numele companiei în cauză, dacă aveți mai multe companii"
Select the relevant company name if you have multiple companies.,"Selectați numele companiei în cauză, dacă aveți mai multe companii."
Select who you want to send this newsletter to,Selectați care doriți să trimiteți acest newsletter
Select your home country and check the timezone and currency.,Selectați țara de origine și să verificați zona de fus orar și moneda.
"Selecting ""Yes"" will allow this item to appear in Purchase Order , Purchase Receipt.","Selectând ""Da"", va permite acest articol să apară în cumparare Ordine, Primirea de cumparare."
"Selecting ""Yes"" will allow this item to figure in Sales Order, Delivery Note","Selectând ""Da"", va permite acest element pentru a figura în comandă de vânzări, livrare Nota"
"Selecting ""Yes"" will allow you to create Bill of Material showing raw material and operational costs incurred to manufacture this item.","Selectând ""Da"", vă va permite să creați Bill of Material arată materii prime și costurile operaționale suportate pentru fabricarea acestui articol."
"Selecting ""Yes"" will allow you to make a Production Order for this item.","Selectând ""Da"", vă va permite să facă o comandă de producție pentru acest articol."
"Selecting ""Yes"" will give a unique identity to each entity of this item which can be viewed in the Serial No master.","Selectând ""Da"", va da o identitate unică pentru fiecare entitate din acest articol, care poate fi vizualizat în ordine maestru."
Selling,De vânzare
Selling Settings,Vanzarea Setări
"Selling must be checked, if Applicable For is selected as {0}","De vânzare trebuie să fie verificate, dacă este cazul Pentru este selectat ca {0}"
Send,Trimiteți
Send Autoreply,Trimite Răspuns automat
Send Email,Trimiteți-ne email
Send From,Trimite la
Send Notifications To,Trimite notificări
Send Now,Trimite Acum
Send SMS,Trimite SMS
Send To,Pentru a trimite
Send To Type,Pentru a trimite Tip
Send mass SMS to your contacts,Trimite SMS-uri în masă a persoanelor de contact
Send to this list,Trimite pe această listă
Sender Name,Sender Name
Sent On,A trimis pe
Separate production order will be created for each finished good item.,Pentru producerea separată va fi creat pentru fiecare articol bun finit.
Serial No,Serial No
Serial No / Batch,Serial No / lot
Serial No Details,Serial Nu Detalii
Serial No Service Contract Expiry,Serial Nu Service Contract de expirare
Serial No Status,Serial Nu Statut
Serial No Warranty Expiry,Serial Nu Garantie pana
Serial No is mandatory for Item {0},Nu serial este obligatorie pentru postul {0}
Serial No {0} created,Serial Nu {0} a creat
Serial No {0} does not belong to Delivery Note {1},Serial Nu {0} nu face parte din livrare Nota {1}
Serial No {0} does not belong to Item {1},Serial Nu {0} nu aparține postul {1}
Serial No {0} does not belong to Warehouse {1},Serial Nu {0} nu apartine Warehouse {1}
Serial No {0} does not exist,Serial Nu {0} nu există
Serial No {0} has already been received,Serial Nu {0} a fost deja primit
Serial No {0} is under maintenance contract upto {1},Serial Nu {0} este sub contract de întreținere pana {1}
Serial No {0} is under warranty upto {1},Serial Nu {0} este în garanție pana {1}
Serial No {0} not in stock,Serial Nu {0} nu este în stoc
Serial No {0} quantity {1} cannot be a fraction,Serial Nu {0} {1} cantitate nu poate fi o fracțiune
Serial No {0} status must be 'Available' to Deliver,"Nu {0} Stare de serie trebuie să fie ""disponibile"" pentru a oferi"
Serial Nos Required for Serialized Item {0},Serial nr necesare pentru postul serializat {0}
Serial Number Series,Număr de serie de serie
Serial number {0} entered more than once,Număr de serie {0} a intrat de mai multe ori
"Serialized Item {0} cannot be updated \
					using Stock Reconciliation","Postul serializat {0} nu poate fi actualizat \
 folosind Bursa de reconciliere"
Series,Serie
Series List for this Transaction,Lista de serie pentru această tranzacție
Series Updated,Seria Actualizat
Series Updated Successfully,Seria Actualizat cu succes
Series is mandatory,Seria este obligatorie
Series {0} already used in {1},Seria {0} folosit deja în {1}
Service,Servicii
Service Address,Adresa serviciu
Service Tax,Serviciul Fiscal
Services,Servicii
Set,Setează
"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Seta valorile implicite, cum ar fi Compania, valutar, Current Anul fiscal, etc"
Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,"Set bugetelor Grupa înțelept Articol de pe acest teritoriu. Puteți include, de asemenea, sezonier prin setarea distribuție."
Set Status as Available,Setați Starea ca Disponibil
Set as Default,Setat ca implicit
Set as Lost,Setați ca Lost
Set prefix for numbering series on your transactions,Set prefix pentru seria de numerotare pe tranzacțiile dvs.
Set targets Item Group-wise for this Sales Person.,Stabilească obiective Articol Grupa-înțelept pentru această persoană de vânzări.
Setting Account Type helps in selecting this Account in transactions.,Setarea Tipul de cont ajută în selectarea acest cont în tranzacții.
Setting this Address Template as default as there is no other default,Setarea acestei Format Adresa implicit ca nu exista nici un alt implicit
Setting up...,Configurarea ...
Settings,Setări
Settings for HR Module,Setările pentru modul HR
"Settings to extract Job Applicants from a mailbox e.g. ""jobs@example.com""","Setări pentru a extrage Solicitanții de locuri de muncă de la o cutie poștală de exemplu ""jobs@example.com"""
Setup,Setare
Setup Already Complete!!,Setup deja complet!
Setup Complete,Configurare complet
Setup SMS gateway settings,Setări de configurare SMS gateway-ul
Setup Series,Seria de configurare
Setup Wizard,Setup Wizard
Setup incoming server for jobs email id. (e.g. jobs@example.com),Configurare de server de intrare pentru ocuparea forței de muncă id-ul de e-mail. (De exemplu jobs@example.com)
Setup incoming server for sales email id. (e.g. sales@example.com),Configurare de server de intrare pentru ID-ul de e-mail de vânzări. (De exemplu sales@example.com)
Setup incoming server for support email id. (e.g. support@example.com),Configurare de server de intrare pentru suport de e-mail id. (De exemplu support@example.com)
Share,Distribuiţi
Share With,Împărtăși cu
Shareholders Funds,Fondurile acționarilor
Shipments to customers.,Transporturile către clienți.
Shipping,Transport
Shipping Account,Contul de transport maritim
Shipping Address,Adresa de livrare
Shipping Amount,Suma de transport maritim
Shipping Rule,Regula de transport maritim
Shipping Rule Condition,Regula Condiții presetate
Shipping Rule Conditions,Condiții Regula de transport maritim
Shipping Rule Label,Regula de transport maritim Label
Shop,Magazin
Shopping Cart,Cosul de cumparaturi
Short biography for website and other publications.,Scurta biografie pentru site-ul web și alte publicații.
"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Arata ""Pe stoc"" sau ""nu este pe stoc"", bazat pe stoc disponibil în acest depozit."
"Show / Hide features like Serial Nos, POS etc.","Arată / Ascunde caracteristici cum ar fi de serie nr, POS etc"
Show In Website,Arată în site-ul
Show a slideshow at the top of the page,Arata un slideshow din partea de sus a paginii
Show in Website,Arata pe site-ul
Show rows with zero values,Arată rânduri cu valori de zero
Show this slideshow at the top of the page,Arată această prezentare în partea de sus a paginii
Sick Leave,A concediului medical
Signature,Semnătura
Signature to be appended at the end of every email,Semnătura să fie adăugată la sfârșitul fiecărui email
Single,Celibatar
Single unit of an Item.,Unitate unică a unui articol.
Sit tight while your system is being setup. This may take a few moments.,Stai bine în timp ce sistemul este în curs de instalare. Acest lucru poate dura câteva momente.
Slideshow,Slideshow
Soap & Detergent,Soap & Detergent
Software,Software
Software Developer,Software Developer
"Sorry, Serial Nos cannot be merged","Ne pare rău, Serial nr nu se pot uni"
"Sorry, companies cannot be merged","Ne pare rău, companiile nu se pot uni"
Source,Sursă
Source File,Sursă de fișiere
Source Warehouse,Depozit sursă
Source and target warehouse cannot be same for row {0},Sursă și depozit țintă nu poate fi același pentru rând {0}
Source of Funds (Liabilities),Sursa fondurilor (pasive)
Source warehouse is mandatory for row {0},Depozit sursă este obligatorie pentru rând {0}
Spartan,Spartan
"Special Characters except ""-"" and ""/"" not allowed in naming series","Caractere speciale, cu excepția ""-"" și ""/"" nu este permis în denumirea serie"
Specification Details,Specificații Detalii
Specifications,Specificaţii:
"Specify a list of Territories, for which, this Price List is valid","Specificați o listă de teritorii, pentru care, aceasta lista de prețuri este valabilă"
"Specify a list of Territories, for which, this Shipping Rule is valid","Specificați o listă de teritorii, pentru care, aceasta regula transport maritim este valabil"
"Specify a list of Territories, for which, this Taxes Master is valid","Specificați o listă de teritorii, pentru care, aceasta Taxe Master este valabil"
"Specify the operations, operating cost and give a unique Operation no to your operations.","Specifica operațiunilor, costurile de exploatare și să dea o operațiune unică nu pentru operațiunile dumneavoastră."
Split Delivery Note into packages.,Împărțit de livrare Notă în pachete.
Sports,Sport
Sr,Sr
Standard,Standard
Standard Buying,Cumpararea Standard
Standard Reports,Rapoarte standard
Standard Selling,Vanzarea Standard
Standard contract terms for Sales or Purchase.,Clauzele contractuale standard pentru vânzări sau de cumpărare.
Start,Început(Pornire)
Start Date,Data începerii
Start date of current invoice's period,Data perioadei de factura de curent începem
Start date should be less than end date for Item {0},Data de începere trebuie să fie mai mică decât data de sfârșit pentru postul {0}
State,Stat
Statement of Account,Extras de cont
Static Parameters,Parametrii statice
Status,Stare
Status must be one of {0},Starea trebuie să fie una din {0}
Status of {0} {1} is now {2},Starea de {0} {1} este acum {2}
Status updated to {0},Starea actualizat la {0}
Statutory info and other general information about your Supplier,Info statutar și alte informații generale despre dvs. de Furnizor
Stay Updated,Stai Actualizat
Stock,Stoc
Stock Adjustment,Ajustarea stoc
Stock Adjustment Account,Cont Ajustarea stoc
Stock Ageing,Stoc Îmbătrânirea
Stock Analytics,Analytics stoc
Stock Assets,Active stoc
Stock Balance,Stoc Sold
Stock Entries already created for Production Order ,
Stock Entry,Stoc de intrare
Stock Entry Detail,Stoc de intrare Detaliu
Stock Expenses,Cheltuieli stoc
Stock Frozen Upto,Stoc Frozen Până la
Stock Ledger,Stoc Ledger
Stock Ledger Entry,Stoc Ledger intrare
Stock Ledger entries balances updated,Stoc Ledger intrări solduri actualizate
Stock Level,Nivelul de stoc
Stock Liabilities,Pasive stoc
Stock Projected Qty,Stoc proiectată Cantitate
Stock Queue (FIFO),Stoc Queue (FIFO)
Stock Received But Not Billed,"Stock primite, dar nu Considerat"
Stock Reconcilation Data,Stoc al reconcilierii datelor
Stock Reconcilation Template,Stoc reconcilierii Format
Stock Reconciliation,Stoc Reconciliere
"Stock Reconciliation can be used to update the stock on a particular date, usually as per physical inventory.","Stock Reconcilierea poate fi utilizată pentru a actualiza stocul de la o anumită dată, de obicei conform inventarului fizic."
Stock Settings,Setări stoc
Stock UOM,Stoc UOM
Stock UOM Replace Utility,Stoc UOM Înlocuiți Utility
Stock UOM updatd for Item {0},Updatd UOM stoc pentru postul {0}
Stock Uom,Stoc UOM
Stock Value,Valoare stoc
Stock Value Difference,Valoarea Stock Diferența
Stock balances updated,Solduri stoc actualizate
Stock cannot be updated against Delivery Note {0},Stock nu poate fi actualizat împotriva livrare Nota {0}
Stock entries exist against warehouse {0} cannot re-assign or modify 'Master Name',"Intrări de stocuri exista împotriva depozit {0} nu poate re-aloca sau modifica ""Maestru Name"""
Stock transactions before {0} are frozen,Tranzacțiilor bursiere înainte de {0} sunt înghețate
Stop,Oprire
Stop Birthday Reminders,De oprire de naștere Memento
Stop Material Request,Oprire Material Cerere
Stop users from making Leave Applications on following days.,Opri utilizatorii de la a face aplicații concediu pentru următoarele zile.
Stop!,Opriti-va!
Stopped,Oprita
Stopped order cannot be cancelled. Unstop to cancel.,Pentru a opri nu pot fi anulate. Unstop pentru a anula.
Stores,Magazine
Stub,Ciot
Sub Assemblies,Sub Assemblies
"Sub-currency. For e.g. ""Cent""","Sub-valută. De exemplu ""Cent """
Subcontract,Subcontract
Subject,Subiect
Submit Salary Slip,Prezenta Salariul Slip
Submit all salary slips for the above selected criteria,Să prezinte toate fișele de salariu pentru criteriile selectate de mai sus
Submit this Production Order for further processing.,Trimiteți acest comandă de producție pentru prelucrarea ulterioară.
Submitted,Inscrisa
Subsidiary,Filială
Successful: ,
Successfully Reconciled,Împăcați cu succes
Suggestions,Sugestii
Sunday,Duminică
Supplier,Furnizor
Supplier (Payable) Account,Furnizor (furnizori) de cont
Supplier (vendor) name as entered in supplier master,"Furnizor (furnizor), nume ca a intrat in legatura cu furnizorul de master"
Supplier > Supplier Type,Furnizor> Furnizor Tip
Supplier Account Head,Furnizor de cont Șeful
Supplier Address,Furnizor Adresa
Supplier Addresses and Contacts,Adrese furnizorului și de Contacte
Supplier Details,Detalii furnizor
Supplier Intro,Furnizor Intro
Supplier Invoice Date,Furnizor Data facturii
Supplier Invoice No,Furnizor Factura Nu
Supplier Name,Furnizor Denumire
Supplier Naming By,Furnizor de denumire prin
Supplier Part Number,Furnizor Număr
Supplier Quotation,Furnizor ofertă
Supplier Quotation Item,Furnizor ofertă Articol
Supplier Reference,Furnizor de referință
Supplier Type,Furnizor Tip
Supplier Type / Supplier,Furnizor Tip / Furnizor
Supplier Type master.,Furnizor de tip maestru.
Supplier Warehouse,Furnizor Warehouse
Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Furnizor Depozit obligatoriu pentru contractate sub-cumparare Primirea
Supplier database.,Baza de date furnizor.
Supplier master.,Furnizor maestru.
Supplier warehouse where you have issued raw materials for sub - contracting,Depozit furnizor în cazul în care au emis materii prime pentru sub - contractare
Supplier-Wise Sales Analytics,Furnizor înțelept Vânzări Analytics
Support,Suport
Support Analtyics,Analtyics Suport
Support Analytics,Suport Analytics
Support Email,Suport de e-mail
Support Email Settings,Suport Setări e-mail
Support Password,Suport Parola
Support Ticket,Bilet de sprijin
Support queries from customers.,Interogări de suport din partea clienților.
Symbol,Simbol
Sync Support Mails,Sync Suport mailuri
Sync with Dropbox,Sincronizare cu Dropbox
Sync with Google Drive,Sincronizare cu Google Drive
System,Sistem
System Settings,Setări de sistem
"System User (login) ID. If set, it will become default for all HR forms.","Utilizator de sistem (login) de identitate. Dacă este setat, el va deveni implicit pentru toate formele de resurse umane."
TDS (Advertisement),TDS (Publicitate)
TDS (Commission),TDS (Comisia)
TDS (Contractor),TDS (Contractor)
TDS (Interest),TDS (dobânzi)
TDS (Rent),TDS (inchiriere)
TDS (Salary),TDS (salariu)
Target  Amount,Suma țintă
Target Detail,Țintă Detaliu
Target Details,Țintă Detalii
Target Details1,Țintă Details1
Target Distribution,Țintă Distribuție
Target On,Țintă pe
Target Qty,Țintă Cantitate
Target Warehouse,Țintă Warehouse
Target warehouse in row {0} must be same as Production Order,Depozit țintă în rândul {0} trebuie să fie același ca și de producție de comandă
Target warehouse is mandatory for row {0},Depozit țintă este obligatorie pentru rând {0}
Task,Operatiune
Task Details,Sarcina Detalii
Tasks,Task-uri
Tax,Impozite
Tax Amount After Discount Amount,Suma taxa După Discount Suma
Tax Assets,Active fiscale
Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,"Taxa Categoria nu poate fi ""de evaluare"" sau ""de evaluare și total"", ca toate elementele sunt produse non-stoc"
Tax Rate,Cota de impozitare
Tax and other salary deductions.,Impozitul și alte rețineri salariale.
"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges","Masă detaliu impozit preluat de la postul de master ca un șir și stocate în acest domeniu.
 Folosit pentru Impozite și Taxe"
Tax template for buying transactions.,Șablon taxa pentru tranzacțiilor de cumpărare.
Tax template for selling transactions.,Șablon impozit pentru tranzacțiile de vânzare.
Taxable,Impozabil
Taxes,Impozite
Taxes and Charges,Impozite și Taxe
Taxes and Charges Added,Impozite și Taxe Added
Taxes and Charges Added (Company Currency),Impozite și Taxe adăugate (Compania de valuta)
Taxes and Charges Calculation,Impozite și Taxe Calcul
Taxes and Charges Deducted,Impozite și Taxe dedus
Taxes and Charges Deducted (Company Currency),Impozite și taxe deduse (Compania de valuta)
Taxes and Charges Total,Impozite și Taxe total
Taxes and Charges Total (Company Currency),Impozite și Taxe total (Compania de valuta)
Technology,Tehnologia nou-aparuta
Telecommunications,Telecomunicații
Telephone Expenses,Cheltuieli de telefon
Television,Televiziune
Template,Sablon
Template for performance appraisals.,Șablon pentru evaluările de performanță.
Template of terms or contract.,Șablon de termeni sau contractului.
Temporary Accounts (Assets),Conturile temporare (Active)
Temporary Accounts (Liabilities),Conturile temporare (pasive)
Temporary Assets,Active temporare
Temporary Liabilities,Pasive temporare
Term Details,Detalii pe termen
Terms,Termeni
Terms and Conditions,Termeni şi condiţii
Terms and Conditions Content,Termeni și condiții de conținut
Terms and Conditions Details,Termeni și condiții Detalii
Terms and Conditions Template,Termeni și condiții Format
Terms and Conditions1,Termeni și Conditions1
Terretory,Terretory
Territory,Teritoriu
Territory / Customer,Teritoriu / client
Territory Manager,Teritoriu Director
Territory Name,Teritoriului Denumire
Territory Target Variance Item Group-Wise,Teritoriul țintă Variance Articol Grupa Înțelept
Territory Targets,Obiective Territory
Test,Teste
Test Email Id,Test de e-mail Id-ul
Test the Newsletter,Testați Newsletter
The BOM which will be replaced,BOM care va fi înlocuit
The First User: You,Primul utilizator:
"The Item that represents the Package. This Item must have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes""","Elementul care reprezintă pachetul. Acest articol trebuie să fi ""Este Piesa"" ca ""Nu"" și ""este produs de vânzări"" ca ""Da"""
The Organization,Organizația
"The account head under Liability, in which Profit/Loss will be booked","Contul capul sub răspunderii, în care Profit / pierdere va fi rezervat"
"The date on which next invoice will be generated. It is generated on submit.
","Data la care va fi generat următoarea factură. Acesta este generat pe prezinte.
"
The date on which recurring invoice will be stop,La data la care factura recurente vor fi opri
"The day of the month on which auto invoice will be generated e.g. 05, 28 etc ",
The day(s) on which you are applying for leave are holiday. You need not apply for leave.,A doua zi (e) pe care aplici pentru concediu sunt vacanță. Tu nu trebuie să se aplice pentru concediu.
The first Leave Approver in the list will be set as the default Leave Approver,Primul Aprobatorul Lăsați în lista va fi setat ca implicit concediu aprobator
The first user will become the System Manager (you can change that later).,Primul utilizator va deveni System Manager (puteți schimba asta mai târziu).
The gross weight of the package. Usually net weight + packaging material weight. (for print),"Greutatea brută a pachetului. Greutate + ambalare, de obicei, greutate netă de material. (Pentru imprimare)"
The name of your company for which you are setting up this system.,Numele companiei dumneavoastră pentru care vă sunt configurarea acestui sistem.
The net weight of this package. (calculated automatically as sum of net weight of items),Greutatea netă a acestui pachet. (Calculat automat ca suma de greutate netă de produs)
The new BOM after replacement,Noul BOM după înlocuirea
The rate at which Bill Currency is converted into company's base currency,Rata la care Bill valuta este convertit în moneda de bază a companiei
The unique id for tracking all recurring invoices. It is generated on submit.,Id-ul unic pentru urmărirea toate facturile recurente. Acesta este generat pe prezinte.
"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Apoi normelor privind prețurile sunt filtrate pe baza Customer, Client Group, Territory, furnizor, furnizor de tip, Campania, Vanzari Partener etc"
There are more holidays than working days this month.,Există mai multe sărbători decât de zile de lucru în această lună.
"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Nu poate fi doar o singură regulă Condiții presetate cu 0 sau o valoare necompletată pentru ""la valoarea"""
There is not enough leave balance for Leave Type {0},Nu există echilibru concediu suficient pentru concediul de tip {0}
There is nothing to edit.,Nu este nimic pentru a edita.
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.,Nu a fost o eroare. Un motiv probabil ar putea fi că nu ați salvat formularul. Vă rugăm să contactați support@erpnext.com dacă problema persistă.
There were errors.,Au fost erori.
This Currency is disabled. Enable to use in transactions,Acest valutar este dezactivată. Permite să folosească în tranzacțiile
This Leave Application is pending approval. Only the Leave Apporver can update status.,Această aplicație concediu este în curs de aprobare. Numai concediu Apporver poate actualiza starea.
This Time Log Batch has been billed.,Acest lot Timpul Log a fost facturat.
This Time Log Batch has been cancelled.,Acest lot Timpul Log a fost anulat.
This Time Log conflicts with {0},This Time Log conflict cu {0}
This format is used if country specific format is not found,Acest format este utilizat în cazul în format specific țării nu este găsit
This is a root account and cannot be edited.,Acesta este un cont de rădăcină și nu pot fi editate.
This is a root customer group and cannot be edited.,Acesta este un grup de clienți rădăcină și nu pot fi editate.
This is a root item group and cannot be edited.,Acesta este un grup element rădăcină și nu pot fi editate.
This is a root sales person and cannot be edited.,Aceasta este o persoană de vânzări rădăcină și nu pot fi editate.
This is a root territory and cannot be edited.,Acesta este un teritoriu rădăcină și nu pot fi editate.
This is an example website auto-generated from ERPNext,Acesta este un site web exemplu auto-generat de ERPNext
This is the number of the last created transaction with this prefix,Acesta este numărul ultimei tranzacții creat cu acest prefix
This will be used for setting rule in HR module,Aceasta va fi utilizată pentru stabilirea regulă în modul de HR
Thread HTML,HTML fir
Thursday,Joi
Time Log,Timp Conectare
Time Log Batch,Timp Log lot
Time Log Batch Detail,Ora Log lot Detaliu
Time Log Batch Details,Timp Jurnal Detalii lot
Time Log Batch {0} must be 'Submitted',"Ora Log Lot {0} trebuie să fie ""Înscris"""
Time Log Status must be Submitted.,Ora Log Starea trebuie să fie prezentate.
Time Log for tasks.,Log timp de sarcini.
Time Log is not billable,Timpul Conectare nu este facturabile
Time Log {0} must be 'Submitted',"Ora Log {0} trebuie să fie ""Înscris"""
Time Zone,Time Zone
Time Zones,Time Zones
Time and Budget,Timp și buget
Time at which items were delivered from warehouse,Timp în care obiectele au fost livrate de la depozit
Time at which materials were received,Timp în care s-au primit materiale
Title,Titlu
Titles for print templates e.g. Proforma Invoice.,"Titluri de șabloane de imprimare, de exemplu proforma Factura."
To,Până la data
To Currency,Pentru a valutar
To Date,La Data
To Date should be same as From Date for Half Day leave,Pentru a Data trebuie să fie aceeași ca la data de concediu de jumatate de zi
To Date should be within the Fiscal Year. Assuming To Date = {0},Pentru a Data ar trebui să fie în anul fiscal. Presupunând Pentru a Data = {0}
To Discuss,Pentru a discuta
To Do List,To do list
To Package No.,La pachetul Nr
To Produce,Pentru a produce
To Time,La timp
To Value,La valoarea
To Warehouse,Pentru Warehouse
"To add child nodes, explore tree and click on the node under which you want to add more nodes.","Pentru a adăuga noduri copil, explora copac și faceți clic pe nodul în care doriți să adăugați mai multe noduri."
"To assign this issue, use the ""Assign"" button in the sidebar.","Pentru a atribui această problemă, utilizați butonul ""Assign"" în bara laterală."
To create a Bank Account,Pentru a crea un cont bancar
To create a Tax Account,Pentru a crea un cont fiscală
"To create an Account Head under a different company, select the company and save customer.","Pentru a crea un cap de cont sub o altă companie, selecta compania și de a salva client."
To date cannot be before from date,Până în prezent nu poate fi înainte de data
To enable <b>Point of Sale</b> features,Pentru a permite <b> Point of Sale </ b> caracteristici
To enable <b>Point of Sale</b> view,Pentru a permite <b> Point of Sale </ b> de vedere
To get Item Group in details table,Pentru a obține Grupa de articole în detalii de masă
"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Pentru a include taxa în rândul {0} în rata articol, impozitele în rânduri {1} trebuie de asemenea să fie incluse"
"To merge, following properties must be same for both items","Pentru a îmbina, următoarele proprietăți trebuie să fie aceeași pentru ambele elemente"
"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","De a nu aplica regula Preturi într-o anumită tranzacție, ar trebui să fie dezactivat toate regulile de tarifare aplicabile."
"To set this Fiscal Year as Default, click on 'Set as Default'","Pentru a seta acest an fiscal ca implicit, faceți clic pe ""Set as Default"""
To track any installation or commissioning related work after sales,Pentru a urmări orice instalare sau punere în lucrările conexe după vânzări
"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","Pentru a urmări nume de marcă în următoarele documente nota de livrare, oportunitate, cerere Material, Item, Ordinul de cumparare, cumparare Voucherul, Cumpărătorul Primirea, cotatie, Factura Vanzare, Vanzari BOM, comandă de vânzări, Serial nr"
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.,"Pentru a urmări element în vânzări și a documentelor de achiziție, pe baza lor de serie nr. Acest lucru se poate, de asemenea, utilizat pentru a urmări detalii de garanție ale produsului."
To track items in sales and purchase documents with batch nos<br><b>Preferred Industry: Chemicals etc</b>,"Pentru a urmări elementele din vânzări și achiziționarea de documente, cu lot nr cui <b> Industrie preferată: Produse chimice etc </ b>"
To track items using barcode. You will be able to enter items in Delivery Note and Sales Invoice by scanning barcode of item.,Pentru a urmări elemente utilizând coduri de bare. Va fi capabil de a intra articole în nota de livrare și factură de vânzare prin scanarea codului de bare de element.
Too many columns. Export the report and print it using a spreadsheet application.,Prea multe coloane. Exporta raportul și imprima utilizând o aplicație de calcul tabelar.
Tools,Instrumentele
Total,totală
Total ({0}),Total ({0})
Total Advance,Total de Advance
Total Amount,Suma totală
Total Amount To Pay,Suma totală să plătească
Total Amount in Words,Suma totală în cuvinte
Total Billing This Year: ,
Total Characters,Total de caractere
Total Claimed Amount,Total suma pretinsă
Total Commission,Total de Comisie
Total Cost,Cost total
Total Credit,Total de Credit
Total Debit,Totală de debit
Total Debit must be equal to Total Credit. The difference is {0},Totală de debit trebuie să fie egal cu total Credit. Diferența este {0}
Total Deduction,Total de deducere
Total Earning,Câștigul salarial total de
Total Experience,Experiența totală
Total Hours,Total ore
Total Hours (Expected),Numărul total de ore (Expected)
Total Invoiced Amount,Sumă totală facturată
Total Leave Days,Total de zile de concediu
Total Leaves Allocated,Totalul Frunze alocate
Total Message(s),Total de mesaje (e)
Total Operating Cost,Cost total de operare
Total Points,Total puncte
Total Raw Material Cost,Cost total de materii prime
Total Sanctioned Amount,Suma totală sancționat
Total Score (Out of 5),Scor total (din 5)
Total Tax (Company Currency),Totală Brut (Compania de valuta)
Total Taxes and Charges,Total Impozite și Taxe
Total Taxes and Charges (Company Currency),Total Impozite si Taxe (Compania valutar)
Total allocated percentage for sales team should be 100,Procentul total alocat pentru echipa de vânzări ar trebui să fie de 100
Total amount of invoices received from suppliers during the digest period,Suma totală a facturilor primite de la furnizori în timpul perioadei Digest
Total amount of invoices sent to the customer during the digest period,Suma totală a facturilor trimise clientului în timpul perioadei Digest
Total cannot be zero,Totală nu poate fi zero
Total in words,Totală în cuvinte
Total points for all goals should be 100. It is {0},Numărul total de puncte pentru toate obiectivele ar trebui să fie de 100. Este {0}
Total valuation for manufactured or repacked item(s) can not be less than total valuation of raw materials,Evaluare totală de element fabricate sau reambalate (e) nu poate fi mai mică de evaluare totală de materii prime
Total weightage assigned should be 100%. It is {0},Weightage total alocat este de 100%. Este {0}
Totals,Totaluri
Track Leads by Industry Type.,Track conduce de Industrie tip.
Track this Delivery Note against any Project,Urmareste acest Livrare Note împotriva oricărui proiect
Track this Sales Order against any Project,Urmareste acest Ordin de vânzări față de orice proiect
Transaction,Tranzacție
Transaction Date,Tranzacție Data
Transaction not allowed against stopped Production Order {0},Tranzacție nu este permis împotriva oprit comandă de producție {0}
Transfer,Transfer
Transfer Material,Material de transfer
Transfer Raw Materials,Transfer de materii prime
Transferred Qty,Transferat Cantitate
Transportation,Transport
Transporter Info,Info Transporter
Transporter Name,Transporter Nume
Transporter lorry number,Număr Transporter camion
Travel,Călători
Travel Expenses,Cheltuieli de călătorie
Tree Type,Arbore Tip
Tree of Item Groups.,Arborele de Postul grupuri.
Tree of finanial Cost Centers.,Arborele de centre de cost finanial.
Tree of finanial accounts.,Arborele de conturi finanial.
Trial Balance,Balanta
Tuesday,Marți
Type,Tip
Type of document to rename.,Tip de document pentru a redenumi.
"Type of leaves like casual, sick etc.","Tip de frunze, cum ar fi casual, bolnavi, etc"
Types of Expense Claim.,Tipuri de cheltuieli de revendicare.
Types of activities for Time Sheets,Tipuri de activități de fișe de pontaj
"Types of employment (permanent, contract, intern etc.).","Tipuri de locuri de muncă (permanent, contractul, intern etc)."
UOM Conversion Detail,Detaliu UOM de conversie
UOM Conversion Details,UOM Detalii de conversie
UOM Conversion Factor,Factorul de conversie UOM
UOM Conversion factor is required in row {0},Factor UOM de conversie este necesară în rândul {0}
UOM Name,Numele UOM
UOM coversion factor required for UOM: {0} in Item: {1},Factor coversion UOM UOM necesare pentru: {0} in articol: {1}
Under AMC,Sub AMC
Under Graduate,Sub Absolvent
Under Warranty,Sub garanție
Unit,Unitate
Unit of Measure,Unitatea de măsură
Unit of Measure {0} has been entered more than once in Conversion Factor Table,Unitate de măsură {0} a fost introdus mai mult de o dată în Factor de conversie Tabelul
"Unit of measurement of this item (e.g. Kg, Unit, No, Pair).","Unitatea de măsură a acestui articol (de exemplu, Kg, Unitatea, Nu, pereche)."
Units/Hour,Unități / oră
Units/Shifts,Unități / Schimburi
Unpaid,Neachitat
Unreconciled Payment Details,Nereconciliate Detalii de plată
Unscheduled,Neprogramat
Unsecured Loans,Creditele negarantate
Unstop,Unstop
Unstop Material Request,Unstop Material Cerere
Unstop Purchase Order,Unstop Comandă
Unsubscribed,Nesubscrise
Update,Actualizați
Update Clearance Date,Actualizare Clearance Data
Update Cost,Actualizare Cost
Update Finished Goods,Marfuri actualizare finite
Update Landed Cost,Actualizare Landed Cost
Update Series,Actualizare Series
Update Series Number,Actualizare Serii Număr
Update Stock,Actualizați Stock
Update bank payment dates with journals.,Actualizați datele de plată bancar cu reviste.
Update clearance date of Journal Entries marked as 'Bank Vouchers',"Data de clearance-ul de actualizare de jurnal intrările marcate ca ""Tichete Bank"""
Updated,Actualizat
Updated Birthday Reminders,Actualizat Data nasterii Memento
Upload Attendance,Încărcați Spectatori
Upload Backups to Dropbox,Încărcați Backup pentru Dropbox
Upload Backups to Google Drive,Încărcați Backup pentru unitate Google
Upload HTML,Încărcați HTML
Upload a .csv file with two columns: the old name and the new name. Max 500 rows.,Încărcați un fișier csv cu două coloane:. Numele vechi și noul nume. Max 500 rânduri.
Upload attendance from a .csv file,Încărcați de participare dintr-un fișier csv.
Upload stock balance via csv.,Încărcați echilibru stoc prin csv.
Upload your letter head and logo - you can edit them later.,Încărcați capul scrisoare și logo-ul - le puteți edita mai târziu.
Upper Income,Venituri de sus
Urgent,De urgență
Use Multi-Level BOM,Utilizarea Multi-Level BOM
Use SSL,Utilizați SSL
Used for Production Plan,Folosit pentru Planul de producție
User,Utilizator
User ID,ID-ul de utilizator
User ID not set for Employee {0},ID-ul de utilizator nu este setat pentru Angajat {0}
User Name,Nume utilizator
User Name or Support Password missing. Please enter and try again.,Numele de utilizator sau parola de sprijin lipsește. Vă rugăm să introduceți și să încercați din nou.
User Remark,Observație utilizator
User Remark will be added to Auto Remark,Observație utilizator va fi adăugat la Auto Observație
User Remarks is mandatory,Utilizatorul Observații este obligatorie
User Specific,Utilizatorul specifică
User must always select,Utilizatorul trebuie să selecteze întotdeauna
User {0} is already assigned to Employee {1},Utilizatorul {0} este deja alocat Angajat {1}
User {0} is disabled,Utilizatorul {0} este dezactivat
Username,Nume utilizator
Users with this role are allowed to create / modify accounting entry before frozen date,Utilizatorii cu acest rol sunt permise pentru a crea / modifica intrare contabilitate înainte de data congelate
Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Utilizatorii cu acest rol le este permis să stabilească conturile înghețate și de a crea / modifica intrări contabile împotriva conturile înghețate
Utilities,Utilities
Utility Expenses,Cheltuieli de utilitate
Valid For Territories,Valabil pentru teritoriile
Valid From,Valabil de la
Valid Upto,Valid Până la
Valid for Territories,Valabil pentru teritoriile
Validate,Valida
Valuation,Evaluare
Valuation Method,Metoda de evaluare
Valuation Rate,Rata de evaluare
Valuation Rate required for Item {0},Rata de evaluare necesar pentru postul {0}
Valuation and Total,Evaluare și Total
Value,Valoare
Value or Qty,Valoare sau Cantitate
Vehicle Dispatch Date,Dispeceratul vehicul Data
Vehicle No,Vehicul Nici
Venture Capital,Capital de Risc
Verified By,Verificate de
View Ledger,Vezi Ledger
View Now,Vezi acum
Visit report for maintenance call.,Vizitați raport de apel de întreținere.
Voucher #,Voucher #
Voucher Detail No,Detaliu voucher Nu
Voucher Detail Number,Voucher Numărul de Detaliu
Voucher ID,ID Voucher
Voucher No,Voletul nr
Voucher Type,Tip Voucher
Voucher Type and Date,Tipul Voucher și data
Walk In,Walk In
Warehouse,Depozit
Warehouse Contact Info,Depozit Contact
Warehouse Detail,Depozit Detaliu
Warehouse Name,Depozit Denumire
Warehouse and Reference,Depozit și de referință
Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Depozit nu pot fi șterse ca exista intrare stoc registrul pentru acest depozit.
Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Depozit poate fi modificat numai prin Bursa de primire de intrare / livrare Nota / cumparare
Warehouse cannot be changed for Serial No.,Depozit nu poate fi schimbat pentru Serial No.
Warehouse is mandatory for stock Item {0} in row {1},Depozit este obligatorie pentru stocul de postul {0} în rândul {1}
Warehouse is missing in Purchase Order,Depozit lipsește în Comandă
Warehouse not found in the system,Depozit nu a fost găsit în sistemul
Warehouse required for stock Item {0},Depozit necesar pentru stocul de postul {0}
Warehouse where you are maintaining stock of rejected items,Depozit în cazul în care se menține stocul de articole respinse
Warehouse {0} can not be deleted as quantity exists for Item {1},Depozit {0} nu poate fi ștearsă ca exista cantitate pentru postul {1}
Warehouse {0} does not belong to company {1},Depozit {0} nu aparține companiei {1}
Warehouse {0} does not exist,Depozit {0} nu există
Warehouse {0}: Company is mandatory,Depozit {0}: Company este obligatorie
Warehouse {0}: Parent account {1} does not bolong to the company {2},Depozit {0}: cont Părinte {1} nu Bolong a companiei {2}
Warehouse-Wise Stock Balance,Depozit-înțelept Stock Balance
Warehouse-wise Item Reorder,-Depozit înțelept Postul de Comandă
Warehouses,Depozite
Warehouses.,Depozite.
Warn,Avertiza
Warning: Leave application contains following block dates,Atenție: Lăsați aplicație conține următoarele date de bloc
Warning: Material Requested Qty is less than Minimum Order Qty,Atenție: Materialul solicitat Cant este mai mică decât minima pentru comanda Cantitate
Warning: Sales Order {0} already exists against same Purchase Order number,Atenție: comandă de vânzări {0} există deja în număr aceeași comandă de aprovizionare
Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Atenție: Sistemul nu va verifica supraîncărcată din sumă pentru postul {0} din {1} este zero
Warranty / AMC Details,Garanție / AMC Detalii
Warranty / AMC Status,Garanție / AMC Starea
Warranty Expiry Date,Garanție Data expirării
Warranty Period (Days),Perioada de garanție (zile)
Warranty Period (in days),Perioada de garanție (în zile)
We buy this Item,Cumparam acest articol
We sell this Item,Vindem acest articol
Website,Site web
Website Description,Site-ul Descriere
Website Item Group,Site-ul Grupa de articole
Website Item Groups,Site-ul Articol Grupuri
Website Settings,Setarile site ului
Website Warehouse,Site-ul Warehouse
Wednesday,Miercuri
Weekly,Saptamanal
Weekly Off,Săptămânal Off
Weight UOM,Greutate UOM
"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Greutate este menționat, \n Vă rugăm să menționați ""Greutate UOM"" prea"
Weightage,Weightage
Weightage (%),Weightage (%)
Welcome,Bine ați venit
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!,"Bine ati venit la ERPNext. De-a lungul următoarele câteva minute va vom ajuta sa de configurare a contului dvs. ERPNext. Încercați și să completați cât mai multe informații aveți, chiar dacă este nevoie de un pic mai mult. Aceasta va salva o mulțime de timp mai târziu. Good Luck!"
Welcome to ERPNext. Please select your language to begin the Setup Wizard.,Bine ati venit la ERPNext. Vă rugăm să selectați limba pentru a începe Expertul de instalare.
What does it do?,Ce face?
"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.","Atunci când oricare dintre tranzacțiile verificate sunt ""Trimis"", un e-mail de tip pop-up a deschis în mod automat pentru a trimite un e-mail la ""Contact"", asociat în această operațiune, cu tranzacția ca un atașament. Utilizatorul poate sau nu poate trimite e-mail."
"When submitted, the system creates difference entries to set the given stock and valuation on this date.","Când a prezentat, sistemul creează intrări diferență pentru a stabili stocul dat și evaluarea la această dată."
Where items are stored.,În cazul în care elementele sunt stocate.
Where manufacturing operations are carried out.,În cazul în care operațiunile de fabricație sunt efectuate.
Widowed,Văduvit
Will be calculated automatically when you enter the details,Vor fi calculate automat atunci când introduceți detaliile
Will be updated after Sales Invoice is Submitted.,Vor fi actualizate după Factura Vanzare este prezentat.
Will be updated when batched.,Vor fi actualizate atunci când dozate.
Will be updated when billed.,Vor fi actualizate atunci când facturat.
Wire Transfer,Transfer
With Operations,Cu Operațiuni
With Period Closing Entry,Cu intrare Perioada de închidere
Work Details,Detalii de lucru
Work Done,Activitatea desfășurată
Work In Progress,Lucrări în curs
Work-in-Progress Warehouse,De lucru-in-Progress Warehouse
Work-in-Progress Warehouse is required before Submit,De lucru-in-Progress Warehouse este necesară înainte Trimite
Working,De lucru
Working Days,Zile lucratoare
Workstation,Stație de lucru
Workstation Name,Stație de lucru Nume
Write Off Account,Scrie Off cont
Write Off Amount,Scrie Off Suma
Write Off Amount <=,Scrie Off Suma <=
Write Off Based On,Scrie Off bazat pe
Write Off Cost Center,Scrie Off cost Center
Write Off Outstanding Amount,Scrie Off remarcabile Suma
Write Off Voucher,Scrie Off Voucher
Wrong Template: Unable to find head row.,Format greșit: Imposibil de găsit rând cap.
Year,An
Year Closed,An Închis
Year End Date,Anul Data de încheiere
Year Name,An Denumire
Year Start Date,An Data începerii
Year of Passing,Ani de la promovarea
Yearly,Anual
Yes,Da
You are not authorized to add or update entries before {0},Tu nu sunt autorizate pentru a adăuga sau actualiza intrări înainte de {0}
You are not authorized to set Frozen value,Tu nu sunt autorizate pentru a seta valoarea Frozen
You are the Expense Approver for this record. Please Update the 'Status' and Save,"Sunteți aprobator cheltuieli pentru acest record. Vă rugăm Actualizați ""statutul"" și Salvare"
You are the Leave Approver for this record. Please Update the 'Status' and Save,"Sunteți aprobator Lăsați pentru această înregistrare. Vă rugăm Actualizați ""statutul"" și Salvare"
You can enter any date manually,Puteți introduce manual orice dată
You can enter the minimum quantity of this item to be ordered.,Puteți introduce cantitatea minimă de acest element pentru a fi comandat.
You can not change rate if BOM mentioned agianst any item,Nu puteți schimba rata dacă BOM menționat agianst orice element
You can not enter both Delivery Note No and Sales Invoice No. Please enter any one.,Nu puteți introduce atât de livrare Notă Nu și Factura Vanzare Nr Vă rugăm să introduceți nici una.
You can not enter current voucher in 'Against Journal Voucher' column,"Nu puteți introduce voucher curent în ""Împotriva Jurnalul Voucher"" coloana"
You can set Default Bank Account in Company master,Puteți seta implicit cont bancar în maestru de companie
You can start by selecting backup frequency and granting access for sync,Puteți începe prin selectarea frecvenței de backup și acordarea de acces pentru sincronizare
You can submit this Stock Reconciliation.,Puteți trimite această Bursa de reconciliere.
You can update either Quantity or Valuation Rate or both.,Puteți actualiza fie Cantitate sau Evaluează evaluare sau ambele.
You cannot credit and debit same account at the same time,"Nu puteți credit și de debit același cont, în același timp,"
You have entered duplicate items. Please rectify and try again.,Ați introdus elemente cu dubluri. Vă rugăm să rectifice și să încercați din nou.
You may need to update: {0},Posibil să aveți nevoie pentru a actualiza: {0}
You must Save the form before proceeding,Trebuie să salvați formularul înainte de a începe
Your Customer's TAX registration numbers (if applicable) or any general information,Numerele de înregistrare fiscală clientului dumneavoastră (dacă este cazul) sau orice informații generale
Your Customers,Clienții dvs.
Your Login Id,Intra Id-ul dvs.
Your Products or Services,Produsele sau serviciile dvs.
Your Suppliers,Furnizorii dumneavoastră
Your email address,Adresa dvs. de e-mail
Your financial year begins on,An dvs. financiar începe la data de
Your financial year ends on,An dvs. financiar se încheie pe
Your sales person who will contact the customer in future,Persoana de vânzări care va contacta clientul în viitor
Your sales person will get a reminder on this date to contact the customer,Persoană de vânzări va primi un memento la această dată pentru a lua legătura cu clientul
Your setup is complete. Refreshing...,Configurarea este completă. Refreshing ...
Your support email id - must be a valid email - this is where your emails will come!,Suport e-mail id-ul dvs. - trebuie să fie un e-mail validă - aceasta este în cazul în care e-mailurile tale vor veni!
[Error],[Eroare]
[Select],[Select]
`Freeze Stocks Older Than` should be smaller than %d days.,`Stocuri Freeze mai în vârstă decât` ar trebui să fie mai mică decât% d zile.
and,și
are not allowed.,nu sunt permise.
assigned by,atribuit de către
cannot be greater than 100,nu poate fi mai mare de 100
"e.g. ""Build tools for builders""","de exemplu ""Construi instrumente de constructori """
"e.g. ""MC""","de exemplu ""MC """
"e.g. ""My Company LLC""","de exemplu ""My Company LLC """
e.g. 5,de exemplu 5
"e.g. Bank, Cash, Credit Card","de exemplu, bancar, Cash, Card de credit"
"e.g. Kg, Unit, Nos, m","de exemplu, Kg, Unitatea, nr, m"
e.g. VAT,"de exemplu, TVA"
eg. Cheque Number,de exemplu. Numărul Cec
example: Next Day Shipping,exemplu: Next Day Shipping
lft,LFT
old_parent,old_parent
rgt,RGT
subject,subiect
to,către
website page link,pagina site-ului link-ul
{0} '{1}' not in Fiscal Year {2},"{0} {1} ""nu este în anul fiscal {2}"
{0} Credit limit {0} crossed,{0} Limita de credit {0} trecut
{0} Serial Numbers required for Item {0}. Only {0} provided.,{0} numere de serie necesare pentru postul {0}. Numai {0} furnizate.
{0} budget for Account {1} against Cost Center {2} will exceed by {3},{0} de buget pentru contul {1} contra cost Centrul de {2} va depăși de {3}
{0} can not be negative,{0} nu poate fi negativ
{0} created,{0} a creat
{0} does not belong to Company {1},{0} nu aparține companiei {1}
{0} entered twice in Item Tax,{0} a intrat de două ori în postul fiscal
{0} is an invalid email address in 'Notification Email Address',"{0} este o adresă de e-mail nevalidă în ""Notificarea Adresa de e-mail"""
{0} is mandatory,{0} este obligatorie
{0} is mandatory for Item {1},{0} este obligatorie pentru postul {1}
{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} este obligatorie. Poate înregistrare de schimb valutar nu este creat pentru {1} la {2}.
{0} is not a stock Item,{0} nu este un element de stoc
{0} is not a valid Batch Number for Item {1},{0} nu este un număr de lot valabil pentru postul {1}
{0} is not a valid Leave Approver. Removing row #{1}.,{0} nu este un concediu aprobator valabil. Scoaterea rând # {1}.
{0} is not a valid email id,{0} nu este un id-ul de e-mail validă
{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} este acum implicit anul fiscal. Vă rugăm să reîmprospătați browser-ul dvs. pentru ca modificarea să aibă efect.
{0} is required,{0} este necesară
{0} must be a Purchased or Sub-Contracted Item in row {1},{0} trebuie sa fie un element Achiziționat sau subcontractate în rândul {1}
{0} must be reduced by {1} or you should increase overflow tolerance,{0} trebuie să fie redusă cu {1} sau ar trebui să crească toleranța preaplin
{0} must have role 'Leave Approver',"{0} trebuie să aibă rol de ""Leave aprobator"""
{0} valid serial nos for Item {1},{0} nos serie valabile pentru postul {1}
{0} {1} against Bill {2} dated {3},{0} {1} împotriva Bill {2} din {3}
{0} {1} against Invoice {2},{0} {1} împotriva Factura {2}
{0} {1} has already been submitted,{0} {1} a fost deja prezentat
{0} {1} has been modified. Please refresh.,{0} {1} a fost modificat. Vă rugăm să reîmprospătați.
{0} {1} is not submitted,{0} {1} nu este prezentată
{0} {1} must be submitted,{0} {1} trebuie să fie prezentate
{0} {1} not in any Fiscal Year,{0} {1} nu într-un an fiscal
{0} {1} status is 'Stopped',"{0} {1} statut este ""Oprit"""
{0} {1} status is Stopped,{0} {1} statut este oprit
{0} {1} status is Unstopped,{0} {1} statut este destupate
{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Cost Center este obligatorie pentru postul {2}
{0}: {1} not found in Invoice Details table,{0}: {1} nu a fost găsit în factură Detalii masă
