diff --git a/erpnext/translations/cz.csv b/erpnext/translations/cz.csv
index fabf35f..2828b83 100644
--- a/erpnext/translations/cz.csv
+++ b/erpnext/translations/cz.csv
@@ -1,686 +1,686 @@
-DocType: Employee,Salary Mode,Mode Plat
-DocType: Cost Center,"Select Monthly Distribution, if you want to track based on seasonality.","Vyberte měsíční výplatou, pokud chcete sledovat na základě sezónnosti."
-DocType: Employee,Divorced,Rozvedený
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +54,Warning: Same item has been entered multiple times.,Upozornění: Stejné položky byl zadán vícekrát.
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +96,Items already synced,Položky již synchronizovat
-DocType: Purchase Order,"If you have created a standard template in Purchase Taxes and Charges Template, select one and click on the button below.","Pokud jste vytvořili standardní šablonu nákupem daní a poplatků šablony, vyberte jednu a klikněte na tlačítko níže."
-apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Materiál Navštivte {0} před zrušením této záruční reklamaci Zrušit
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +18,Consumer Products,Spotřební zboží
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +72,Please select Party Type first,"Prosím, vyberte typ Party první"
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +89,Annealing,Žíhání
-DocType: Item,Customer Items,Zákazník položky
-apps/erpnext/erpnext/accounts/doctype/account/account.py +41,Account {0}: Parent account {1} can not be a ledger,Účet {0}: Nadřazený účet {1} nemůže být hlavní kniha
-DocType: Item,Publish Item to hub.erpnext.com,Publikování položku do hub.erpnext.com
-apps/erpnext/erpnext/config/setup.py +63,Email Notifications,E-mailová upozornění
-DocType: Item,Default Unit of Measure,Výchozí Měrná jednotka
-DocType: SMS Center,All Sales Partner Contact,Všechny Partneři Kontakt
-DocType: Employee,Leave Approvers,Nechte schvalovatelů
-DocType: Sales Partner,Dealer,Dealer
-DocType: Employee,Rented,Pronajato
-DocType: Stock Entry,Get Stock and Rate,Získejte skladem a Rate
-DocType: About Us Settings,Website,Stránky
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +22,Compaction plus sintering,Zhutňování a spékání
-DocType: Sales BOM,"The Item that represents the Package. This Item must have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes""","Položka, která představuje balíček. Tato položka musí mít ""je skladem"" jako ""No"" a ""Je Sales Item"" jako ""Yes"""
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +99,Currency is required for Price List {0},Měna je vyžadováno pro Ceníku {0}
-DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Bude se vypočítá v transakci.
-apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +125,Please enter Employee Id of this sales parson,"Prosím, zadejte ID zaměstnance této kupní farář"
-apps/erpnext/erpnext/setup/doctype/backup_manager/backup_googledrive.py +120,Please set Google Drive access keys in {0},Prosím nastavte klíče pro přístup Google Drive In {0}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +542,From Material Request,Z materiálu Poptávka
-apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +39,{0} Tree,{0} Strom
-DocType: Job Applicant,Job Applicant,Job Žadatel
-apps/erpnext/erpnext/hub_node/page/hub/hub_body.html +18,No more results.,Žádné další výsledky.
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +73,Legal,Právní
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +114,Actual type tax cannot be included in Item rate in row {0},Aktuální typ daň nemůže být zahrnutý v ceně Položka v řádku {0}
-DocType: C-Form,Customer,Zákazník
-DocType: Purchase Receipt Item,Required By,Vyžadováno
-DocType: Department,Department,Oddělení
-DocType: Purchase Order,% Billed,% Fakturováno
-DocType: Selling Settings,Customer Name,Jméno zákazníka
-DocType: Features Setup,"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.","Všech oblastech souvisejících vývozní jako měnu, přepočítacího koeficientu, export celkem, export celkovém součtu etc jsou k dispozici v dodací list, POS, citace, prodejní faktury, prodejní objednávky atd"
-DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,"Heads (nebo skupiny), proti nimž účetní zápisy jsou vyrobeny a stav je veden."
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +143,Outstanding for {0} cannot be less than zero ({1}),Vynikající pro {0} nemůže být nižší než nula ({1})
-DocType: Manufacturing Settings,Default 10 mins,Výchozí 10 min
-DocType: Leave Type,Leave Type Name,Nechte Typ Jméno
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +143,Series Updated Successfully,Řada Aktualizováno Úspěšně
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +149,Stitching,Šití
-DocType: Pricing Rule,Apply On,Naneste na
-DocType: Item Price,Multiple Item prices.,Více ceny položku.
-,Purchase Order Items To Be Received,Položky vydané objednávky k přijetí
-DocType: SMS Center,All Supplier Contact,Vše Dodavatel Kontakt
-DocType: Quality Inspection Reading,Parameter,Parametr
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +52,Please specify a Price List which is valid for Territory,"Uveďte prosím ceníku, který je platný pro území"
-apps/erpnext/erpnext/projects/doctype/project/project.py +35,Expected End Date can not be less than Expected Start Date,"Očekávané Datum ukončení nemůže být nižší, než se očekávalo data zahájení"
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +235,Do really want to unstop production order:,Opravdu chcete uvolnit výrobní zakázky: 
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +190,New Leave Application,New Leave Application
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +129,Bank Draft,Bank Návrh
-DocType: Features Setup,1. To maintain the customer wise item code and to make them searchable based on their code use this option,"1.Chcete-li zachovat zákazníkovo produktové číslo a také podle něj vyhledávat, použijte tuto možnost"
-DocType: Mode of Payment Account,Mode of Payment Account,Způsob platby účtu
-apps/erpnext/erpnext/stock/doctype/item/item.js +60,Show Variants,Zobrazit Varianty
-DocType: Sales Invoice Item,Quantity,Množství
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +174,Loans (Liabilities),Úvěry (závazky)
-DocType: Employee Education,Year of Passing,Rok Passing
-DocType: Designation,Designation,Označení
-DocType: Production Plan Item,Production Plan Item,Výrobní program Item
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +137,User {0} is already assigned to Employee {1},Uživatel {0} je již přiřazena k Employee {1}
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +30,Health Care,Péče o zdraví
-DocType: Purchase Invoice,Monthly,Měsíčně
-apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +66,Invoice,Faktura
-DocType: Maintenance Schedule Item,Periodicity,Periodicita
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +355,Email Address,E-mailová adresa
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +20,Defense,Obrana
-DocType: Company,Abbr,Zkr
-DocType: Appraisal Goal,Score (0-5),Score (0-5)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +205,Row {0}: {1} {2} does not match with {3},Řádek {0}: {1} {2} se neshoduje s {3}
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +62,Row # {0}:,Řádek # {0}:
-DocType: Delivery Note,Vehicle No,Vozidle
-sites/assets/js/erpnext.min.js +50,Please select Price List,"Prosím, vyberte Ceník"
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +161,Woodworking,Zpracování dřeva
-DocType: Production Order Operation,Work In Progress,Work in Progress
-DocType: Company,If Monthly Budget Exceeded,Pokud Měsíční rozpočet překročen
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +152,3D printing,3D tisk
-DocType: Employee,Holiday List,Dovolená Seznam
-DocType: Time Log,Time Log,Time Log
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +80,Accountant,Účetní
-DocType: Company,Phone No,Telefon
-DocType: Time Log,"Log of Activities performed by users against Tasks that can be used for tracking time, billing.","Log činností vykonávaných uživateli proti úkoly, které mohou být použity pro sledování času, fakturaci."
-apps/erpnext/erpnext/controllers/recurring_document.py +125,New {0}: #{1},Nový {0}: # {1}
-,Sales Partners Commission,Obchodní partneři Komise
-apps/erpnext/erpnext/setup/doctype/company/company.py +31,Abbreviation cannot have more than 5 characters,Zkratka nesmí mít více než 5 znaků
-DocType: Backup Manager,Allow Google Drive Access,Povolit Google disku přístup
-DocType: Email Digest,Projects & System,Projekty a System
-DocType: Print Settings,Classic,Klasické
-apps/erpnext/erpnext/accounts/doctype/account/account.js +27,This is a root account and cannot be edited.,To je kořen účtu a nelze upravovat.
-DocType: Shopping Cart Settings,Shipping Rules,Přepravní řád
-DocType: BOM,Operations,Operace
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38,Cannot set authorization on basis of Discount for {0},Nelze nastavit oprávnění na základě Sleva pro {0}
-DocType: Bin,Quantity Requested for Purchase,Požadovaného množství na nákup
-DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Připojit CSV soubor se dvěma sloupci, jeden pro starý název a jeden pro nový název"
-DocType: Packed Item,Parent Detail docname,Parent Detail docname
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +574,Kg,Kg
-apps/erpnext/erpnext/config/hr.py +48,Opening for a Job.,Otevření o zaměstnání.
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +5,Advertising,Reklama
-DocType: Employee,Married,Ženatý
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +339,Stock cannot be updated against Delivery Note {0},Sklad nelze aktualizovat na dodací list {0}
-DocType: Payment Reconciliation,Reconcile,Srovnat
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +29,Grocery,Potraviny
-DocType: Quality Inspection Reading,Reading 1,Čtení 1
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +93,Make Bank Entry,Proveďte Bank Vstup
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +39,Pension Funds,Penzijní fondy
-apps/erpnext/erpnext/accounts/doctype/account/account.py +116,Warehouse is mandatory if account type is Warehouse,"Sklad je povinné, pokud typ účtu je Warehouse"
-DocType: SMS Center,All Sales Person,Všichni obchodní zástupci
-DocType: Backup Manager,Credentials,Pověřovací listiny
-DocType: Purchase Order,"Check if recurring order, uncheck to stop recurring or put proper End Date","Zkontrolujte, zda je opakující se, zrušte zaškrtnutí políčka zastavit opakované nebo dát správné datum ukončení"
-DocType: Sales Invoice Item,Sales Invoice Item,Prodejní faktuře položka
-DocType: Account,Credit,Úvěr
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +25,Please setup Employee Naming System in Human Resource > HR Settings,"Prosím, setup zaměstnanců pojmenování systému v oblasti lidských zdrojů> Nastavení HR"
-DocType: POS Setting,Write Off Cost Center,Odepsat nákladové středisko
-DocType: Warehouse,Warehouse Detail,Sklad Detail
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +159,Credit limit has been crossed for customer {0} {1}/{2},Úvěrový limit byla překročena o zákazníka {0} {1} / {2}
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +114,You are not authorized to add or update entries before {0},Nejste oprávněni přidávat nebo aktualizovat údaje před {0}
-apps/erpnext/erpnext/selling/doctype/sales_bom/sales_bom.py +27,Parent Item {0} must be not Stock Item and must be a Sales Item,Parent Item {0} nesmí být skladem a musí být prodejní položky
-DocType: Item,Item Image (if not slideshow),Item Image (ne-li slideshow)
-apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,An Customer exists with same name,Zákazník existuje se stejným názvem
-DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Hodina Rate / 60) * Skutečná Provozní doba
-DocType: SMS Log,SMS Log,SMS Log
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Náklady na dodávaných výrobků
-DocType: Blog Post,Guest,Host
-DocType: Quality Inspection,Get Specification Details,Získat Specifikace Podrobnosti
-DocType: Lead,Interested,Zájemci
-apps/erpnext/erpnext/config/manufacturing.py +14,Bill of Material,Bill of materiálu
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32,From {0} to {1},Od {0} do {1}
-DocType: Item,Copy From Item Group,Kopírovat z bodu Group
-DocType: Journal Entry,Opening Entry,Otevření Entry
-apps/erpnext/erpnext/controllers/trends.py +33,{0} is mandatory,{0} je povinné
-apps/erpnext/erpnext/config/setup.py +111,Contact master.,Kontakt master.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +87,Account with existing transaction can not be converted to group.,Účet s transakcemi nelze převést na skupinu.
-DocType: Lead,Product Enquiry,Dotaz Product
-DocType: Standard Reply,Owner,Majitel
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +13,Please enter company first,"Prosím, nejprave zadejte společnost"
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +35,Please select Company first,"Prosím, vyberte první firma"
-DocType: Employee Education,Under Graduate,Za absolventa
-apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +22,Target On,Target On
-DocType: BOM,Total Cost,Celkové náklady
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +98,Reaming,Vystružování
-DocType: Email Digest,Stub,Pahýl
-apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.js +8,Activity Log:,Aktivita Log:
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +202,Item {0} does not exist in the system or has expired,Bod {0} neexistuje v systému nebo vypršela
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +43,Real Estate,Nemovitost
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +4,Statement of Account,Výpis z účtu
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +40,Pharmaceuticals,Farmaceutické
-DocType: Expense Claim Detail,Claim Amount,Nárok Částka
-DocType: Employee,Mr,Pan
-DocType: Custom Script,Client,Klient
-apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +33,Supplier Type / Supplier,Dodavatel Typ / dovozce
-DocType: Naming Series,Prefix,Prefix
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +571,Consumable,Spotřební
-DocType: Upload Attendance,Import Log,Záznam importu
-apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.js +19,Send,Odeslat
-DocType: SMS Center,All Contact,Vše Kontakt
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +159,Annual Salary,Roční Plat
-DocType: Period Closing Voucher,Closing Fiscal Year,Uzavření fiskálního roku
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +69,Stock Expenses,Stock Náklady
-DocType: Newsletter,Email Sent?,E-mail odeslán?
-DocType: Journal Entry,Contra Entry,Contra Entry
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +89,Show Time Logs,Show Time Záznamy
-DocType: Email Digest,Bank/Cash Balance,Bank / Cash Balance
-DocType: Delivery Note,Installation Status,Stav instalace
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +97,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Schválené + Zamítnuté množství se musí rovnat množství Přijaté u položky {0}
-DocType: Item,Supply Raw Materials for Purchase,Dodávky suroviny pro nákup
-apps/erpnext/erpnext/stock/get_item_details.py +134,Item {0} must be a Purchase Item,Bod {0} musí být Nákup položky
-DocType: Upload Attendance,"Download the Template, fill appropriate data and attach the modified file.
+Salary Mode,Mode Plat,
+"Select Monthly Distribution, if you want to track based on seasonality.","Vyberte měsíční výplatou, pokud chcete sledovat na základě sezónnosti."
+Divorced,Rozveden$1,
+Warning: Same item has been entered multiple times.,Upozornění: Stejné položky byl zadán vícekrát.
+Items already synced,Položky již synchronizovat,
+"If you have created a standard template in Purchase Taxes and Charges Template, select one and click on the button below.","Pokud jste vytvořili standardní šablonu nákupem daní a poplatků šablony, vyberte jednu a klikněte na tlačítko níže."
+Cancel Material Visit {0} before cancelling this Warranty Claim,Materiál Navštivte {0} před zrušením této záruční reklamaci Zrušit,
+Consumer Products,Spotřební zbožt,
+Please select Party Type first,"Prosím, vyberte typ Party první"
+Annealing,Žíhány,
+Customer Items,Zákazník položky,
+Account {0}: Parent account {1} can not be a ledger,Účet {0}: Nadřazený účet {1} nemůže být hlavní kniha,
+Publish Item to hub.erpnext.com,Publikování položku do hub.erpnext.com,
+Email Notifications,E-mailová upozorněny,
+Default Unit of Measure,Výchozí Měrná jednotka,
+All Sales Partner Contact,Všechny Partneři Kontakt,
+Leave Approvers,Nechte schvalovately,
+Dealer,Dealer,
+Rented,Pronajato,
+Get Stock and Rate,Získejte skladem a Rate,
+Website,Stránky,
+Compaction plus sintering,Zhutňování a spékány,
+"The Item that represents the Package. This Item must have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes""","Položka, která představuje balíček. Tato položka musí mít ""je skladem"" jako ""No"" a ""Je Sales Item"" jako ""Yes"""
+Currency is required for Price List {0},Měna je vyžadováno pro Ceníku {0}
+* Will be calculated in the transaction.,* Bude se vypočítá v transakci.
+Please enter Employee Id of this sales parson,"Prosím, zadejte ID zaměstnance této kupní farář"
+Please set Google Drive access keys in {0},Prosím nastavte klíče pro přístup Google Drive In {0}
+From Material Request,Z materiálu Poptávka,
+{0} Tree,{0} Strom,
+Job Applicant,Job Žadatel,
+No more results.,Žádné další výsledky.
+Legal,Právn$1,
+Actual type tax cannot be included in Item rate in row {0},Aktuální typ daň nemůže být zahrnutý v ceně Položka v řádku {0}
+Customer,Zákazník,
+Required By,Vyžadováno,
+Department,Oddělenk,
+% Billed,% Fakturováno,
+Customer Name,Jméno zákazníka,
+"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.","Všech oblastech souvisejících vývozní jako měnu, přepočítacího koeficientu, export celkem, export celkovém součtu etc jsou k dispozici v dodací list, POS, citace, prodejní faktury, prodejní objednávky atd"
+Heads (or groups) against which Accounting Entries are made and balances are maintained.,"Heads (nebo skupiny), proti nimž účetní zápisy jsou vyrobeny a stav je veden."
+Outstanding for {0} cannot be less than zero ({1}),Vynikající pro {0} nemůže být nižší než nula ({1})
+Default 10 mins,Výchozí 10 min,
+Leave Type Name,Nechte Typ Jméno,
+Series Updated Successfully,Řada Aktualizováno Úspěšnn,
+Stitching,Šitn,
+Apply On,Naneste na,
+Multiple Item prices.,Více ceny položku.
+Purchase Order Items To Be Received,Položky vydané objednávky k přijett,
+All Supplier Contact,Vše Dodavatel Kontakt,
+Parameter,Parametr,
+Please specify a Price List which is valid for Territory,"Uveďte prosím ceníku, který je platný pro území"
+Expected End Date can not be less than Expected Start Date,"Očekávané Datum ukončení nemůže být nižší, než se očekávalo data zahájení"
+Do really want to unstop production order:,Opravdu chcete uvolnit výrobní zakázky: 
+New Leave Application,New Leave Application,
+Bank Draft,Bank Návrh,
+1. To maintain the customer wise item code and to make them searchable based on their code use this option,"1.Chcete-li zachovat zákazníkovo produktové číslo a také podle něj vyhledávat, použijte tuto možnost"
+Mode of Payment Account,Způsob platby účtu,
+Show Variants,Zobrazit Varianty,
+Quantity,Množstvu,
+Loans (Liabilities),Úvěry (závazky)
+Year of Passing,Rok Passing,
+Designation,Označeng,
+Production Plan Item,Výrobní program Item,
+User {0} is already assigned to Employee {1},Uživatel {0} je již přiřazena k Employee {1}
+Health Care,Péče o zdrava,
+Monthly,Měsíčna,
+Invoice,Faktura,
+Periodicity,Periodicita,
+Email Address,E-mailová adresa,
+Defense,Obrana,
+Abbr,Zkr,
+Score (0-5),Score (0-5)
+Row {0}: {1} {2} does not match with {3},Řádek {0}: {1} {2} se neshoduje s {3}
+Row # {0}:,Řádek # {0}:
+Vehicle No,Vozidle,
+Please select Price List,"Prosím, vyberte Ceník"
+Woodworking,Zpracování dřeva,
+Work In Progress,Work in Progress,
+If Monthly Budget Exceeded,Pokud Měsíční rozpočet překročen,
+3D printing,3D tisk,
+Holiday List,Dovolená Seznam,
+Time Log,Time Log,
+Accountant,Účetna,
+Phone No,Telefon,
+"Log of Activities performed by users against Tasks that can be used for tracking time, billing.","Log činností vykonávaných uživateli proti úkoly, které mohou být použity pro sledování času, fakturaci."
+New {0}: #{1},Nový {0}: # {1}
+Sales Partners Commission,Obchodní partneři Komise,
+Abbreviation cannot have more than 5 characters,Zkratka nesmí mít více než 5 znake,
+Allow Google Drive Access,Povolit Google disku přístup,
+Projects & System,Projekty a System,
+Classic,Klasicke,
+This is a root account and cannot be edited.,To je kořen účtu a nelze upravovat.
+Shipping Rules,Přepravní řád,
+Operations,Operace,
+Cannot set authorization on basis of Discount for {0},Nelze nastavit oprávnění na základě Sleva pro {0}
+Quantity Requested for Purchase,Požadovaného množství na nákup,
+"Attach .csv file with two columns, one for the old name and one for the new name","Připojit CSV soubor se dvěma sloupci, jeden pro starý název a jeden pro nový název"
+Parent Detail docname,Parent Detail docname,
+Kg,Kg,
+Opening for a Job.,Otevření o zaměstnání.
+Advertising,Reklama,
+Married,Ženata,
+Stock cannot be updated against Delivery Note {0},Sklad nelze aktualizovat na dodací list {0}
+Reconcile,Srovnat,
+Grocery,Potraviny,
+Reading 1,Čtení 1,
+Make Bank Entry,Proveďte Bank Vstup,
+Pension Funds,Penzijní fondy,
+Warehouse is mandatory if account type is Warehouse,"Sklad je povinné, pokud typ účtu je Warehouse"
+All Sales Person,Všichni obchodní zástupci,
+Credentials,Pověřovací listiny,
+"Check if recurring order, uncheck to stop recurring or put proper End Date","Zkontrolujte, zda je opakující se, zrušte zaškrtnutí políčka zastavit opakované nebo dát správné datum ukončení"
+Sales Invoice Item,Prodejní faktuře položka,
+Credit,Úvěr,
+Please setup Employee Naming System in Human Resource > HR Settings,"Prosím, setup zaměstnanců pojmenování systému v oblasti lidských zdrojů> Nastavení HR"
+Write Off Cost Center,Odepsat nákladové středisko,
+Warehouse Detail,Sklad Detail,
+Credit limit has been crossed for customer {0} {1}/{2},Úvěrový limit byla překročena o zákazníka {0} {1} / {2}
+You are not authorized to add or update entries before {0},Nejste oprávněni přidávat nebo aktualizovat údaje před {0}
+Parent Item {0} must be not Stock Item and must be a Sales Item,Parent Item {0} nesmí být skladem a musí být prodejní položky,
+Item Image (if not slideshow),Item Image (ne-li slideshow)
+An Customer exists with same name,Zákazník existuje se stejným názvem,
+(Hour Rate / 60) * Actual Operation Time,(Hodina Rate / 60) * Skutečná Provozní doba,
+SMS Log,SMS Log,
+Cost of Delivered Items,Náklady na dodávaných výrobkm,
+Guest,Host,
+Get Specification Details,Získat Specifikace Podrobnosti,
+Interested,Zájemci,
+Bill of Material,Bill of materiálu,
+From {0} to {1},Od {0} do {1}
+Copy From Item Group,Kopírovat z bodu Group,
+Opening Entry,Otevření Entry,
+{0} is mandatory,{0} je povinnp,
+Contact master.,Kontakt master.
+Account with existing transaction can not be converted to group.,Účet s transakcemi nelze převést na skupinu.
+Product Enquiry,Dotaz Product,
+Owner,Majitel,
+Please enter company first,"Prosím, nejprave zadejte společnost"
+Please select Company first,"Prosím, vyberte první firma"
+Under Graduate,Za absolventa,
+Target On,Target On,
+Total Cost,Celkové náklady,
+Reaming,Vystružována,
+Stub,Pahýl,
+Activity Log:,Aktivita Log:
+Item {0} does not exist in the system or has expired,Bod {0} neexistuje v systému nebo vypršela,
+Real Estate,Nemovitost,
+Statement of Account,Výpis z účtu,
+Pharmaceuticals,Farmaceuticka,
+Claim Amount,Nárok Částka,
+Mr,Pan,
+Client,Klient,
+Supplier Type / Supplier,Dodavatel Typ / dovozce,
+Prefix,Prefix,
+Consumable,Spotřebna,
+Import Log,Záznam importu,
+Send,Odeslat,
+All Contact,Vše Kontakt,
+Annual Salary,Roční Plat,
+Closing Fiscal Year,Uzavření fiskálního roku,
+Stock Expenses,Stock Náklady,
+Email Sent?,E-mail odeslán?
+Contra Entry,Contra Entry,
+Show Time Logs,Show Time Záznamy,
+Bank/Cash Balance,Bank / Cash Balance,
+Installation Status,Stav instalace,
+Accepted + Rejected Qty must be equal to Received quantity for Item {0},Schválené + Zamítnuté množství se musí rovnat množství Přijaté u položky {0}
+Supply Raw Materials for Purchase,Dodávky suroviny pro nákup,
+Item {0} must be a Purchase Item,Bod {0} musí být Nákup položky,
+"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","Stáhněte si šablony, vyplňte potřebné údaje a přiložte upravený soubor.
  Všechny termíny a zaměstnanec kombinaci ve zvoleném období přijde v šabloně, se stávajícími evidence docházky"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +496,Item {0} is not active or end of life has been reached,"Bod {0} není aktivní, nebo byl dosažen konec života"
-DocType: Time Log Batch,Will be updated after Sales Invoice is Submitted.,Bude aktualizováno po odeslání faktury.
-apps/erpnext/erpnext/controllers/accounts_controller.py +385,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Chcete-li zahrnout daně na řádku v poměru Položka {0}, daně v řádcích {1} musí být zahrnuty"
-apps/erpnext/erpnext/config/hr.py +90,Settings for HR Module,Nastavení pro HR modul
-DocType: SMS Center,SMS Center,SMS centrum
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +77,Straightening,Rovnací
-DocType: BOM Replace Tool,New BOM,New BOM
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +132,There were no updates in the items selected for this digest.,Nebyly zjištěny žádné aktualizace ve vybraných položek pro tento digest.
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +14,Countergravity casting,Countergravity lití
-apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +28,Newsletter has already been sent,Newsletter již byla odeslána
-DocType: Lead,Request Type,Typ požadavku
-DocType: Leave Application,Reason,Důvod
-DocType: Purchase Invoice,The rate at which Bill Currency is converted into company's base currency,"Sazba, za kterou je Bill měny převeden do společnosti základní měny"
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +13,Broadcasting,Vysílání
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +135,Execution,Provedení
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +362,The first user will become the System Manager (you can change this later).,První uživatel bude System Manager (lze později změnit).
-apps/erpnext/erpnext/config/manufacturing.py +39,Details of the operations carried out.,Podrobnosti o prováděných operací.
-DocType: Serial No,Maintenance Status,Status Maintenance
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +37,From Date should be within the Fiscal Year. Assuming From Date = {0},"Od data by měla být v rámci fiskálního roku. Za předpokladu, že od data = {0}"
-DocType: Appraisal,Select the Employee for whom you are creating the Appraisal.,"Vyberte zaměstnance, pro kterého vytváříte hodnocení."
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +90,Cost Center {0} does not belong to Company {1},Náklady Center {0} nepatří do společnosti {1}
-DocType: Customer,Individual,Individuální
-apps/erpnext/erpnext/config/support.py +23,Plan for maintenance visits.,Plán pro návštěvy údržby.
-DocType: SMS Settings,Enter url parameter for message,Zadejte url parametr zprávy
-apps/erpnext/erpnext/config/selling.py +143,Rules for applying pricing and discount.,Pravidla pro používání cen a slevy.
-apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,Ceník musí být použitelný pro nákup nebo prodej
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +90,Installation date cannot be before delivery date for Item {0},Datum Instalace nemůže být před datem dodání pro bod {0}
-sites/assets/js/form.min.js +261,Start,Start
-DocType: User,First Name,Křestní jméno
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +602,Your setup is complete. Refreshing.,Nastavení je dokončeno. Aktualizuji.
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +11,Full-mold casting,Lití Full-forma
-DocType: Offer Letter,Select Terms and Conditions,Vyberte Podmínky
-DocType: Email Digest,Payments made during the digest period,Platby provedené v období digest
-DocType: Production Planning Tool,Sales Orders,Prodejní objednávky
-DocType: Purchase Taxes and Charges,Valuation,Ocenění
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +17,Set as Default,Nastavit jako výchozí
-,Purchase Order Trends,Nákupní objednávka trendy
-apps/erpnext/erpnext/config/hr.py +78,Allocate leaves for the year.,Přidělit listy za rok.
-DocType: Earning Type,Earning Type,Výdělek Type
-DocType: Email Digest,New Sales Orders,Nové Prodejní objednávky
-DocType: Bank Reconciliation,Bank Account,Bankovní účet
-DocType: Leave Type,Allow Negative Balance,Povolit záporný zůstatek
-DocType: Email Digest,Receivable / Payable account will be identified based on the field Master Type,Pohledávka / Závazek účet bude určen na základě hlavního pole typu
-DocType: Selling Settings,Default Territory,Výchozí Territory
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +52,Television,Televize
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +137,Gashing,Rozsekne
-DocType: Production Order Operation,Updated via 'Time Log',"Aktualizováno přes ""Time Log"""
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +76,Account {0} does not belong to Company {1},Účet {0} nepatří do společnosti {1}
-DocType: Naming Series,Series List for this Transaction,Řada seznam pro tuto transakci
-apps/erpnext/erpnext/controllers/selling_controller.py +176,Reserved Warehouse required for stock Item {0} in row {1},Vyhrazeno Warehouse potřebný pro živočišnou item {0} v řadě {1}
-DocType: Sales Invoice,Is Opening Entry,Je vstupní otvor
-DocType: Supplier,Mention if non-standard receivable account applicable,Zmínka v případě nestandardní pohledávky účet použitelná
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +145,For Warehouse is required before Submit,Pro Sklad je povinné před Odesláním
-DocType: Sales Partner,Reseller,Reseller
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +49,Please enter Company,"Prosím, zadejte společnost"
-DocType: Delivery Note Item,Against Sales Invoice Item,Proti položce vydané faktury
-,Production Orders in Progress,Zakázka na výrobu v Progress
-DocType: Item,Auto-raise Material Request if quantity goes below re-order level in default warehouse,"Auto-raise Material žádosti, pokud množství klesne pod úroveň re-pořadí, ve výchozím skladu"
-DocType: Journal Entry,Write Off Amount <=,Napište jednorázová částka <=
-DocType: Lead,Address & Contact,Adresa a kontakt
-apps/erpnext/erpnext/controllers/recurring_document.py +205,Next Recurring {0} will be created on {1},Další Opakující {0} bude vytvořen na {1}
-DocType: POS Setting,Create Stock Ledger Entries when you submit a Sales Invoice,Vytvořte Stock Ledger záznamy při odeslání prodejní faktuře
-DocType: Newsletter List,Total Subscribers,Celkem Odběratelé
-DocType: Lead,Contact Name,Kontakt Jméno
-DocType: Production Plan Item,SO Pending Qty,SO Pending Množství
-DocType: Salary Manager,Creates salary slip for above mentioned criteria.,Vytvoří výplatní pásku na výše uvedených kritérií.
-apps/erpnext/erpnext/templates/generators/item.html +21,No description given,No vzhledem k tomu popis
-apps/erpnext/erpnext/config/buying.py +18,Request for purchase.,Žádost o koupi.
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +106,Double housing,Double bydlení
-DocType: Item,"Unit of measurement of this item (e.g. Kg, Unit, No, Pair).","Jednotka měření této položky (např Kg, Unit, No, pár)."
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +157,Only the selected Leave Approver can submit this Leave Application,Pouze vybraný Leave schvalovač může podat této dovolené aplikaci
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +110,Relieving Date must be greater than Date of Joining,Uvolnění Datum musí být větší než Datum spojování
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +167,Leaves per Year,Listy za rok
-DocType: Time Log,Will be updated when batched.,Bude aktualizována při dávkově.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +123,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Row {0}: Zkontrolujte ""Je Advance"" proti účtu {1}, pokud je to záloha záznam."
-apps/erpnext/erpnext/stock/utils.py +174,Warehouse {0} does not belong to company {1},Sklad {0} nepatří ke společnosti {1}
-DocType: Brand,Material Master Manager,Materiál Hlavní manažer
-DocType: Bulk Email,Message,Zpráva
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +663,Pending Items {0} updated,Nevyřízené položky {0} Aktualizováno
-DocType: Item Website Specification,Item Website Specification,Položka webových stránek Specifikace
-DocType: Backup Manager,Dropbox Access Key,Dropbox Access Key
-DocType: Payment Tool,Reference No,Referenční číslo
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +342,Leave Blocked,Nechte Blokováno
-apps/erpnext/erpnext/stock/doctype/item/item.py +465,Item {0} has reached its end of life on {1},Položka {0} dosáhla konce své životnosti na {1}
-apps/erpnext/erpnext/accounts/utils.py +306,Annual,Roční
-DocType: Stock Reconciliation Item,Stock Reconciliation Item,Reklamní Odsouhlasení Item
-DocType: Purchase Invoice,In Words will be visible once you save the Purchase Invoice.,"Ve slovech budou viditelné, jakmile uložíte o nákupu."
-DocType: Stock Entry,Sales Invoice No,Prodejní faktuře č
-DocType: Material Request Item,Min Order Qty,Min Objednané množství
-DocType: Lead,Do Not Contact,Nekontaktujte
-DocType: Sales Invoice,The unique id for tracking all recurring invoices. It is generated on submit.,Unikátní ID pro sledování všech opakující faktury. To je generován na odeslat.
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +88,Software Developer,Software Developer
-DocType: Item,Minimum Order Qty,Minimální objednávka Množství
-DocType: Pricing Rule,Supplier Type,Dodavatel Type
-DocType: Item,Publish in Hub,Publikovat v Hub
-,Terretory,Terretory
-apps/erpnext/erpnext/stock/doctype/item/item.py +482,Item {0} is cancelled,Položka {0} je zrušen
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +620,Material Request,Požadavek na materiál
-DocType: Bank Reconciliation,Update Clearance Date,Aktualizace Výprodej Datum
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +128,Wire brushing,Wire kartáčování
-DocType: Employee,Relation,Vztah
-apps/erpnext/erpnext/config/selling.py +23,Confirmed orders from Customers.,Potvrzené objednávky od zákazníků.
-DocType: Purchase Receipt Item,Rejected Quantity,Zamítnuto Množství
-DocType: Features Setup,"Field available in Delivery Note, Quotation, Sales Invoice, Sales Order","Pole k dispozici v dodací list, cenovou nabídku, prodejní faktury odběratele"
-DocType: SMS Settings,SMS Sender Name,SMS Sender Name
-DocType: Contact,Is Primary Contact,Je primárně Kontakt
-DocType: Notification Control,Notification Control,Oznámení Control
-DocType: Lead,Suggestions,Návrhy
-DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Set Položka Skupina-moudrý rozpočty na tomto území. Můžete také sezónnosti nastavením distribuce.
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +72,Please enter parent account group for warehouse {0},"Prosím, zadejte mateřskou skupinu účtu pro sklad {0}"
-DocType: Supplier,Address HTML,Adresa HTML
-DocType: Lead,Mobile No.,Mobile No.
-DocType: Maintenance Schedule,Generate Schedule,Generování plán
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +80,Hubbing,Hubbing
-DocType: Purchase Invoice Item,Expense Head,Náklady Head
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +86,Please select Charge Type first,"Prosím, vyberte druh tarifu první"
-apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Nejnovější
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +393,Max 5 characters,Max 5 znaků
-DocType: Email Digest,New Quotations,Nové Citace
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +194,Select Your Language,Zvolit jazyk
-DocType: Employee,The first Leave Approver in the list will be set as the default Leave Approver,První Leave schvalovač v seznamu bude nastaven jako výchozí Leave schvalujícího
-DocType: Accounts Settings,Settings for Accounts,Nastavení účtů
-apps/erpnext/erpnext/config/crm.py +80,Manage Sales Person Tree.,Správa obchodník strom.
-DocType: Item,Synced With Hub,Synchronizovány Hub
-DocType: Item,Variant Of,Varianta
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +35,Item {0} must be Service Item,Položka {0} musí být Service Item
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +297,Completed Qty can not be greater than 'Qty to Manufacture',"Dokončené množství nemůže být větší než ""Množství do výroby"""
-DocType: DocType,Administrator,Správce
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +135,Laser drilling,Laserové vrtání
-DocType: Stock UOM Replace Utility,New Stock UOM,Nových akcií UOM
-DocType: Period Closing Voucher,Closing Account Head,Závěrečný účet hlava
-DocType: Shopping Cart Settings,"<a href=""#Sales Browser/Customer Group"">Add / Edit</a>","<a href=""#Sales Browser/Customer Group""> Přidat / Upravit </a>"
-DocType: Employee,External Work History,Vnější práce History
-apps/erpnext/erpnext/projects/doctype/task/task.py +86,Circular Reference Error,Kruhové Referenční Chyba
-DocType: ToDo,Closed,Zavřeno
-DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,"Ve slovech (export) budou viditelné, jakmile uložíte doručení poznámku."
-DocType: Lead,Industry,Průmysl
-DocType: Employee,Job Profile,Job Profile
-DocType: Newsletter,Newsletter,Newsletter
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +83,Hydroforming,Hydroforming
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +48,Necking,Zúžení
-DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Upozornit e-mailem na tvorbu automatických Materiál Poptávka
-apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +29,Item is updated,Položka je aktualizována
-apps/erpnext/erpnext/accounts/doctype/pos_setting/pos_setting.py +26,Global POS Setting {0} already created for company {1},Global POS nastavení {0} již vytvořený pro společnost {1}
-DocType: Comment,System Manager,Správce systému
-DocType: Payment Reconciliation Invoice,Invoice Type,Typ faktury
-DocType: Sales Invoice Item,Delivery Note,Dodací list
-DocType: Backup Manager,Allow Dropbox Access,Povolit přístup Dropbox
-DocType: Communication,Support Manager,Manažer podpory
-DocType: Sales Order Item,Reserved Warehouse,Vyhrazeno Warehouse
-apps/erpnext/erpnext/accounts/utils.py +182,Payment Entry has been modified after you pulled it. Please pull it again.,"Vstup Platba byla změněna poté, co ji vytáhl. Prosím, vytáhněte ji znovu."
-apps/erpnext/erpnext/stock/doctype/item/item.py +337,{0} entered twice in Item Tax,{0} vloženo dvakrát v Daňové Položce
-DocType: Workstation,Rent Cost,Rent Cost
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +73,Please select month and year,Vyberte měsíc a rok
-DocType: Purchase Invoice,"Enter email id separated by commas, invoice will be mailed automatically on particular date","Zadejte e-mail id odděleny čárkami, bude faktura bude zaslán automaticky na určité datum"
-DocType: Employee,Company Email,Společnost E-mail
-DocType: Workflow State,Refresh,obnovit
-DocType: Features Setup,"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.","Všech souvisejících oblastech, jako je dovozní měně, přepočítací koeficient, dovoz celkem, dovoz celkovém součtu etc jsou k dispozici v dokladu o koupi, dodavatelů nabídky, faktury, objednávky apod"
-apps/erpnext/erpnext/stock/doctype/item/item.js +59,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"Tento bod je šablona a nemůže být použit v transakcích. Atributy položky budou zkopírovány do variant, pokud je nastaveno ""No Copy"""
-apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +59,Total Order Considered,Celková objednávka Zvážil
-DocType: Sales Invoice Item,Discount (%),Sleva (%)
-apps/erpnext/erpnext/config/hr.py +110,"Employee designation (e.g. CEO, Director etc.).","Označení zaměstnanců (např CEO, ředitel atd.)."
-apps/erpnext/erpnext/controllers/recurring_document.py +198,Please enter 'Repeat on Day of Month' field value,"Prosím, zadejte ""Opakujte dne měsíce"" hodnoty pole"
-DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,"Sazba, za kterou je zákazník měny převeden na zákazníka základní měny"
-DocType: Features Setup,"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet","K dispozici v BOM, dodací list, fakturu, výrobní zakázky, objednávky, doklad o koupi, prodejní faktury odběratele, Stock vstupu, časový rozvrh"
-DocType: Item Tax,Tax Rate,Tax Rate
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +510,Select Item,Select Položka
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +208,{0} {1} status is Stopped,{0} {1} status je zastavena
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +138,"Item: {0} managed batch-wise, can not be reconciled using \
+Item {0} is not active or end of life has been reached,"Bod {0} není aktivní, nebo byl dosažen konec života"
+Will be updated after Sales Invoice is Submitted.,Bude aktualizováno po odeslání faktury.
+"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Chcete-li zahrnout daně na řádku v poměru Položka {0}, daně v řádcích {1} musí být zahrnuty"
+Settings for HR Module,Nastavení pro HR modul,
+SMS Center,SMS centrum,
+Straightening,Rovnacl,
+New BOM,New BOM,
+There were no updates in the items selected for this digest.,Nebyly zjištěny žádné aktualizace ve vybraných položek pro tento digest.
+Countergravity casting,Countergravity lita,
+Newsletter has already been sent,Newsletter již byla odeslána,
+Request Type,Typ požadavku,
+Reason,Důvod,
+The rate at which Bill Currency is converted into company's base currency,"Sazba, za kterou je Bill měny převeden do společnosti základní měny"
+Broadcasting,Vysílán$1,
+Execution,Proveden$1,
+The first user will become the System Manager (you can change this later).,První uživatel bude System Manager (lze později změnit).
+Details of the operations carried out.,Podrobnosti o prováděných operací.
+Maintenance Status,Status Maintenance,
+From Date should be within the Fiscal Year. Assuming From Date = {0},"Od data by měla být v rámci fiskálního roku. Za předpokladu, že od data = {0}"
+Select the Employee for whom you are creating the Appraisal.,"Vyberte zaměstnance, pro kterého vytváříte hodnocení."
+Cost Center {0} does not belong to Company {1},Náklady Center {0} nepatří do společnosti {1}
+Individual,Individuáln$1,
+Plan for maintenance visits.,Plán pro návštěvy údržby.
+Enter url parameter for message,Zadejte url parametr zprávy,
+Rules for applying pricing and discount.,Pravidla pro používání cen a slevy.
+Price List must be applicable for Buying or Selling,Ceník musí být použitelný pro nákup nebo prodej,
+Installation date cannot be before delivery date for Item {0},Datum Instalace nemůže být před datem dodání pro bod {0}
+Start,Start,
+First Name,Křestní jméno,
+Your setup is complete. Refreshing.,Nastavení je dokončeno. Aktualizuji.
+Full-mold casting,Lití Full-forma,
+Select Terms and Conditions,Vyberte Podmínky,
+Payments made during the digest period,Platby provedené v období digest,
+Sales Orders,Prodejní objednávky,
+Valuation,Oceněna,
+Set as Default,Nastavit jako výchoza,
+Purchase Order Trends,Nákupní objednávka trendy,
+Allocate leaves for the year.,Přidělit listy za rok.
+Earning Type,Výdělek Type,
+New Sales Orders,Nové Prodejní objednávky,
+Bank Account,Bankovní účet,
+Allow Negative Balance,Povolit záporný zůstatek,
+Receivable / Payable account will be identified based on the field Master Type,Pohledávka / Závazek účet bude určen na základě hlavního pole typu,
+Default Territory,Výchozí Territory,
+Television,Televize,
+Gashing,Rozsekne,
+Updated via 'Time Log',"Aktualizováno přes ""Time Log"""
+Account {0} does not belong to Company {1},Účet {0} nepatří do společnosti {1}
+Series List for this Transaction,Řada seznam pro tuto transakci,
+Reserved Warehouse required for stock Item {0} in row {1},Vyhrazeno Warehouse potřebný pro živočišnou item {0} v řadě {1}
+Is Opening Entry,Je vstupní otvor,
+Mention if non-standard receivable account applicable,Zmínka v případě nestandardní pohledávky účet použitelnr,
+For Warehouse is required before Submit,Pro Sklad je povinné před Odesláním,
+Reseller,Reseller,
+Please enter Company,"Prosím, zadejte společnost"
+Against Sales Invoice Item,Proti položce vydané faktury,
+Production Orders in Progress,Zakázka na výrobu v Progress,
+Auto-raise Material Request if quantity goes below re-order level in default warehouse,"Auto-raise Material žádosti, pokud množství klesne pod úroveň re-pořadí, ve výchozím skladu"
+Write Off Amount <=,Napište jednorázová částka <=
+Address & Contact,Adresa a kontakt,
+Next Recurring {0} will be created on {1},Další Opakující {0} bude vytvořen na {1}
+Create Stock Ledger Entries when you submit a Sales Invoice,Vytvořte Stock Ledger záznamy při odeslání prodejní faktuře,
+Total Subscribers,Celkem Odběratele,
+Contact Name,Kontakt Jméno,
+SO Pending Qty,SO Pending Množstve,
+Creates salary slip for above mentioned criteria.,Vytvoří výplatní pásku na výše uvedených kritérií.
+No description given,No vzhledem k tomu popis,
+Request for purchase.,Žádost o koupi.
+Double housing,Double bydlen$1,
+"Unit of measurement of this item (e.g. Kg, Unit, No, Pair).","Jednotka měření této položky (např Kg, Unit, No, pár)."
+Only the selected Leave Approver can submit this Leave Application,Pouze vybraný Leave schvalovač může podat této dovolené aplikaci,
+Relieving Date must be greater than Date of Joining,Uvolnění Datum musí být větší než Datum spojováni,
+Leaves per Year,Listy za rok,
+Will be updated when batched.,Bude aktualizována při dávkově.
+Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Row {0}: Zkontrolujte ""Je Advance"" proti účtu {1}, pokud je to záloha záznam."
+Warehouse {0} does not belong to company {1},Sklad {0} nepatří ke společnosti {1}
+Material Master Manager,Materiál Hlavní manažer,
+Message,Zpráva,
+Pending Items {0} updated,Nevyřízené položky {0} Aktualizováno,
+Item Website Specification,Položka webových stránek Specifikace,
+Dropbox Access Key,Dropbox Access Key,
+Reference No,Referenční číslo,
+Leave Blocked,Nechte Blokováno,
+Item {0} has reached its end of life on {1},Položka {0} dosáhla konce své životnosti na {1}
+Annual,Ročnm,
+Stock Reconciliation Item,Reklamní Odsouhlasení Item,
+In Words will be visible once you save the Purchase Invoice.,"Ve slovech budou viditelné, jakmile uložíte o nákupu."
+Sales Invoice No,Prodejní faktuře e,
+Min Order Qty,Min Objednané množstve,
+Do Not Contact,Nekontaktujte,
+The unique id for tracking all recurring invoices. It is generated on submit.,Unikátní ID pro sledování všech opakující faktury. To je generován na odeslat.
+Software Developer,Software Developer,
+Minimum Order Qty,Minimální objednávka Množstvr,
+Supplier Type,Dodavatel Type,
+Publish in Hub,Publikovat v Hub,
+Terretory,Terretory,
+Item {0} is cancelled,Položka {0} je zrušen,
+Material Request,Požadavek na materiál,
+Update Clearance Date,Aktualizace Výprodej Datum,
+Wire brushing,Wire kartáčovánr,
+Relation,Vztah,
+Confirmed orders from Customers.,Potvrzené objednávky od zákazníků.
+Rejected Quantity,Zamítnuto Množstv$1,
+"Field available in Delivery Note, Quotation, Sales Invoice, Sales Order","Pole k dispozici v dodací list, cenovou nabídku, prodejní faktury odběratele"
+SMS Sender Name,SMS Sender Name,
+Is Primary Contact,Je primárně Kontakt,
+Notification Control,Oznámení Control,
+Suggestions,Návrhy,
+Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Set Položka Skupina-moudrý rozpočty na tomto území. Můžete také sezónnosti nastavením distribuce.
+Please enter parent account group for warehouse {0},"Prosím, zadejte mateřskou skupinu účtu pro sklad {0}"
+Address HTML,Adresa HTML,
+Mobile No.,Mobile No.
+Generate Schedule,Generování plán,
+Hubbing,Hubbing,
+Expense Head,Náklady Head,
+Please select Charge Type first,"Prosím, vyberte druh tarifu první"
+Latest,Nejnovějše,
+Max 5 characters,Max 5 znake,
+New Quotations,Nové Citace,
+Select Your Language,Zvolit jazyk,
+The first Leave Approver in the list will be set as the default Leave Approver,První Leave schvalovač v seznamu bude nastaven jako výchozí Leave schvalujícího,
+Settings for Accounts,Nastavení účte,
+Manage Sales Person Tree.,Správa obchodník strom.
+Synced With Hub,Synchronizovány Hub,
+Variant Of,Varianta,
+Item {0} must be Service Item,Položka {0} musí být Service Item,
+Completed Qty can not be greater than 'Qty to Manufacture',"Dokončené množství nemůže být větší než ""Množství do výroby"""
+Administrator,Správce,
+Laser drilling,Laserové vrtáne,
+New Stock UOM,Nových akcií UOM,
+Closing Account Head,Závěrečný účet hlava,
+"<a href=""#Sales Browser/Customer Group"">Add / Edit</a>","<a href=""#Sales Browser/Customer Group""> Přidat / Upravit </a>"
+External Work History,Vnější práce History,
+Circular Reference Error,Kruhové Referenční Chyba,
+Closed,Zavřeno,
+In Words (Export) will be visible once you save the Delivery Note.,"Ve slovech (export) budou viditelné, jakmile uložíte doručení poznámku."
+Industry,Průmysl,
+Job Profile,Job Profile,
+Newsletter,Newsletter,
+Hydroforming,Hydroforming,
+Necking,Zúženl,
+Notify by Email on creation of automatic Material Request,Upozornit e-mailem na tvorbu automatických Materiál Poptávka,
+Item is updated,Položka je aktualizována,
+Global POS Setting {0} already created for company {1},Global POS nastavení {0} již vytvořený pro společnost {1}
+System Manager,Správce systému,
+Invoice Type,Typ faktury,
+Delivery Note,Dodací list,
+Allow Dropbox Access,Povolit přístup Dropbox,
+Support Manager,Manažer podpory,
+Reserved Warehouse,Vyhrazeno Warehouse,
+Payment Entry has been modified after you pulled it. Please pull it again.,"Vstup Platba byla změněna poté, co ji vytáhl. Prosím, vytáhněte ji znovu."
+{0} entered twice in Item Tax,{0} vloženo dvakrát v Daňové Položce,
+Rent Cost,Rent Cost,
+Please select month and year,Vyberte měsíc a rok,
+"Enter email id separated by commas, invoice will be mailed automatically on particular date","Zadejte e-mail id odděleny čárkami, bude faktura bude zaslán automaticky na určité datum"
+Company Email,Společnost E-mail,
+Refresh,obnovit,
+"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.","Všech souvisejících oblastech, jako je dovozní měně, přepočítací koeficient, dovoz celkem, dovoz celkovém součtu etc jsou k dispozici v dokladu o koupi, dodavatelů nabídky, faktury, objednávky apod"
+This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"Tento bod je šablona a nemůže být použit v transakcích. Atributy položky budou zkopírovány do variant, pokud je nastaveno ""No Copy"""
+Total Order Considered,Celková objednávka Zvážil,
+Discount (%),Sleva (%)
+"Employee designation (e.g. CEO, Director etc.).","Označení zaměstnanců (např CEO, ředitel atd.)."
+Please enter 'Repeat on Day of Month' field value,"Prosím, zadejte ""Opakujte dne měsíce"" hodnoty pole"
+Rate at which Customer Currency is converted to customer's base currency,"Sazba, za kterou je zákazník měny převeden na zákazníka základní měny"
+"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet","K dispozici v BOM, dodací list, fakturu, výrobní zakázky, objednávky, doklad o koupi, prodejní faktury odběratele, Stock vstupu, časový rozvrh"
+Tax Rate,Tax Rate,
+Select Item,Select Položka,
+{0} {1} status is Stopped,{0} {1} status je zastavena,
+"Item: {0} managed batch-wise, can not be reconciled using \
 					Stock Reconciliation, instead use Stock Entry","Item: {0} podařilo dávkové, nemůže být v souladu s použitím \
  Stock usmíření, použijte Reklamní Entry"
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +242,Purchase Invoice {0} is already submitted,Přijatá faktura {0} je již odeslána
-apps/erpnext/erpnext/accounts/doctype/account/account.js +54,Convert to non-Group,Převést na non-Group
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Purchase Receipt must be submitted,Příjmka musí být odeslána
-DocType: Stock UOM Replace Utility,Current Stock UOM,Current Reklamní UOM
-apps/erpnext/erpnext/config/stock.py +53,Batch (lot) of an Item.,Batch (lot) položky.
-DocType: C-Form Invoice Detail,Invoice Date,Datum Fakturace
-apps/erpnext/erpnext/stock/doctype/item/item.py +358,"As there are existing stock transactions for this item, you can not change the values of 'Has Serial No', 'Has Batch No', 'Is Stock Item' and 'Valuation Method'","Jelikož jsou stávající skladové transakce za tuto položku, nelze změnit hodnoty ""Má pořadové číslo"", ""má Batch ne"", ""Je skladem"" a ""oceňování metoda"""
-apps/erpnext/erpnext/templates/includes/footer_extension.html +6,Your email address,Vaše e-mailová adresa
-DocType: Email Digest,Income booked for the digest period,Příjmy žlutou kartu za období digest
-apps/erpnext/erpnext/config/setup.py +106,Supplier master.,Dodavatel master.
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +191,Please see attachment,"Prosím, viz příloha"
-DocType: Purchase Order,% Received,% Přijaté
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +108,Water jet cutting,Řezání vodním paprskem
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +22,Setup Already Complete!!,Setup již dokončen !!
-,Finished Goods,Hotové zboží
-DocType: Delivery Note,Instructions,Instrukce
-DocType: Quality Inspection,Inspected By,Zkontrolován
-DocType: Maintenance Visit,Maintenance Type,Typ Maintenance
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +69,Serial No {0} does not belong to Delivery Note {1},Pořadové číslo {0} není součástí dodávky Poznámka: {1}
-DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Položka Kontrola jakosti Parametr
-DocType: Leave Application,Leave Approver Name,Nechte schvalovač Jméno
-,Schedule Date,Plán Datum
-DocType: Packed Item,Packed Item,Zabalená položka
-apps/erpnext/erpnext/config/buying.py +54,Default settings for buying transactions.,Výchozí nastavení pro nákup transakcí.
-apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +23,Activity Cost exists for Employee {0} against Activity Type - {1},Existuje Náklady aktivity pro zaměstnance {0} proti Typ aktivity - {1}
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +29,Please do NOT create Accounts for Customers and Suppliers. They are created directly from the Customer / Supplier masters.,"Prosím, ne vytvářet účty pro zákazníky a dodavateli. Jsou vytvořeny přímo od zákazníka / dodavatele mistrů."
-DocType: Currency Exchange,Currency Exchange,Směnárna
-DocType: Purchase Invoice Item,Item Name,Název položky
-apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Credit Balance,Credit Balance
-DocType: Employee,Widowed,Ovdovělý
-DocType: Production Planning Tool,"Items to be requested which are ""Out of Stock"" considering all warehouses based on projected qty and minimum order qty","Položky, které je třeba požádat, které jsou ""Není skladem"" s ohledem na veškeré sklady na základě předpokládaného Množství a minimální Objednané množství"
-DocType: Workstation,Working Hours,Pracovní doba
-DocType: Naming Series,Change the starting / current sequence number of an existing series.,Změnit výchozí / aktuální pořadové číslo existujícího série.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +57,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Je-li více pravidla pro tvorbu cen i nadále přednost, jsou uživatelé vyzváni k nastavení priority pro vyřešení konfliktu."
-DocType: Stock Entry,Purchase Return,Nákup Return
-,Purchase Register,Nákup Register
-DocType: Item,"Selecting ""Yes"" will allow this item to figure in Sales Order, Delivery Note","Výběr ""Ano"" umožní tato položka přijít na odběratele, dodací list"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +212,Please enter Purchase Receipt No to proceed,Zadejte prosím doklad o koupi No pokračovat
-DocType: Landed Cost Item,Applicable Charges,Použitelné Poplatky
-DocType: Workstation,Consumable Cost,Spotřební Cost
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +153,{0} ({1}) must have role 'Leave Approver',"{0} ({1}), musí mít roli ""Schvalovatel dovolených"""
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +39,Medical,Lékařský
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +124,Reason for losing,Důvod ztráty
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +35,Tube beading,Tube navlékání korálků
-apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +79,Workstation is closed on the following dates as per Holiday List: {0},Workstation je uzavřena v následujících dnech podle Prázdninový Seznam: {0}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +638,Make Maint. Schedule,Proveďte údržba. Plán
-DocType: Employee,Single,Jednolůžkový
-DocType: Account,Cost of Goods Sold,Náklady na prodej zboží
-DocType: Purchase Invoice,Yearly,Ročně
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +217,Please enter Cost Center,"Prosím, zadejte nákladové středisko"
-DocType: Sales Invoice Item,Sales Order,Prodejní objednávky
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +63,Avg. Selling Rate,Avg. Prodej Rate
-DocType: Purchase Order,Start date of current order's period,Datum období současného objednávky Začátek
-apps/erpnext/erpnext/utilities/transaction_base.py +113,Quantity cannot be a fraction in row {0},Množství nemůže být zlomek na řádku {0}
-DocType: Purchase Invoice Item,Quantity and Rate,Množství a cena
-DocType: Delivery Note,% Installed,% Instalováno
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +60,Please enter company name first,"Prosím, zadejte nejprve název společnosti"
-DocType: BOM,Item Desription,Položka Desription
-DocType: Buying Settings,Supplier Name,Dodavatel Name
-DocType: Account,Is Group,Is Group
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +30,Thermoforming,Tvarování
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +65,Slitting,Kotoučová
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.',"""DO Případu č ' nesmí být menší než ""Od Případu č '"
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +99,Non Profit,Non Profit
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_list.js +7,Not Started,Nezahájeno
-DocType: Lead,Channel Partner,Channel Partner
-DocType: Account,Old Parent,Staré nadřazené
-DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,"Přizpůsobte si úvodní text, který jede jako součást tohoto e-mailu. Každá transakce je samostatný úvodní text."
-DocType: Sales Taxes and Charges Template,Sales Master Manager,Sales manažer ve skupině Master
-apps/erpnext/erpnext/config/manufacturing.py +66,Global settings for all manufacturing processes.,Globální nastavení pro všechny výrobní procesy.
-DocType: Accounts Settings,Accounts Frozen Upto,Účty Frozen aľ
-DocType: SMS Log,Sent On,Poslán na
-DocType: Sales Order,Not Applicable,Nehodí se
-apps/erpnext/erpnext/config/hr.py +140,Holiday master.,Holiday master.
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +18,Shell molding,Shell lití
-DocType: Material Request Item,Required Date,Požadovaná data
-DocType: Delivery Note,Billing Address,Fakturační adresa
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +611,Please enter Item Code.,"Prosím, zadejte kód položky."
-DocType: BOM,Costing,Rozpočet
-DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Je-li zaškrtnuto, bude částka daně považovat za již zahrnuty v tisku Rate / Tisk Částka"
-apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Qty,Celkem Množství
-DocType: Employee,Health Concerns,Zdravotní Obavy
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +13,Unpaid,Nezaplacený
-DocType: Packing Slip,From Package No.,Od č balíčku
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29,Securities and Deposits,Cenné papíry a vklady
-DocType: Features Setup,Imports,Importy
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +143,Adhesive bonding,Lepení
-DocType: Job Opening,Description of a Job Opening,Popis jednoho volných pozic
-apps/erpnext/erpnext/config/hr.py +28,Attendance record.,Účast rekord.
-DocType: Bank Reconciliation,Journal Entries,Zápisy do Deníku
-DocType: Sales Order Item,Used for Production Plan,Používá se pro výrobní plán
-DocType: System Settings,Loading...,Nahrávám...
-DocType: DocField,Password,Heslo
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +154,Fused deposition modeling,Nánosový modelování depozice
-DocType: Manufacturing Settings,Time Between Operations (in mins),Doba mezi operací (v min)
-DocType: Backup Manager,"Note: Backups and files are not deleted from Google Drive, you will have to delete them manually.","Poznámka: Zálohy a soubory nejsou odstraněny z Disku Google, budete muset odstranit ručně."
-DocType: Customer,Buyer of Goods and Services.,Kupující zboží a služeb.
-DocType: Journal Entry,Accounts Payable,Účty za úplatu
-apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +24,Add Subscribers,Přidat předplatitelé
-sites/assets/js/erpnext.min.js +2,""" does not exists",""" Neexistuje"
-DocType: Pricing Rule,Valid Upto,Valid aľ
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +514,List a few of your customers. They could be organizations or individuals.,Seznam několik svých zákazníků. Ty by mohly být organizace nebo jednotlivci.
-DocType: Email Digest,Open Tickets,Otevřené Vstupenky
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Direct Income,Přímý příjmů
-DocType: Email Digest,Total amount of invoices received from suppliers during the digest period,Celková výše přijatých faktur od dodavatelů během období digest
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +29,"Can not filter based on Account, if grouped by Account","Nelze filtrovat na základě účtu, pokud seskupeny podle účtu"
-DocType: Item,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.,"Dodací lhůta dnech je počet dní, o nichž je tato položka očekává ve skladu. Tento dnech je přitažené za vlasy v hmotné požadavku při výběru této položky."
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +83,Administrative Officer,Správní ředitel
-DocType: Payment Tool,Received Or Paid,Přijaté nebo placené
-DocType: Item,"Select ""Yes"" if this item is used for some internal purpose in your company.","Zvolte ""Ano"", pokud tato položka se používá pro některé interní účely ve vaší firmě."
-DocType: Stock Entry,Difference Account,Rozdíl účtu
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +307,Please enter Warehouse for which Material Request will be raised,"Prosím, zadejte sklad, který bude materiál žádosti předložené"
-DocType: Production Order,Additional Operating Cost,Další provozní náklady
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +19,Cosmetics,Kosmetika
-DocType: DocField,Type,Typ
-apps/erpnext/erpnext/stock/doctype/item/item.py +413,"To merge, following properties must be same for both items","Chcete-li sloučit, tyto vlastnosti musí být stejné pro obě položky"
-DocType: Backup Manager,Email ids separated by commas.,E-mailové ID oddělené čárkami.
-DocType: Communication,Subject,Předmět
-DocType: Item,"Select ""Yes"" if this item represents some work like training, designing, consulting etc.","Zvolte ""Ano"", pokud je tato položka představuje nějakou práci, jako je vzdělávání, projektování, konzultace atd."
-DocType: Shipping Rule,Net Weight,Hmotnost
-DocType: Employee,Emergency Phone,Nouzový telefon
-DocType: Backup Manager,Google Drive Access Allowed,Google Drive Přístup povolen
-,Serial No Warranty Expiry,Pořadové č záruční lhůty
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +634,Do you really want to STOP this Material Request?,Opravdu chcete zastavit tento materiál požadavek?
-DocType: Purchase Invoice Item,Item,Položka
-DocType: Journal Entry,Difference (Dr - Cr),Rozdíl (Dr - Cr)
-DocType: Account,Profit and Loss,Zisky a ztráty
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +310,Upcoming Calendar Events (max 10),Nadcházející Události v kalendáři (max 10)
-apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +101,New UOM must NOT be of type Whole Number,New UOM NESMÍ být typu celé číslo
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +47,Furniture and Fixture,Nábytek
-DocType: Quotation,Rate at which Price list currency is converted to company's base currency,"Sazba, za kterou Ceník měna je převedena na společnosti základní měny"
-apps/erpnext/erpnext/setup/doctype/company/company.py +48,Account {0} does not belong to company: {1},Účet {0} nepatří k firmě: {1}
-DocType: Selling Settings,Default Customer Group,Výchozí Customer Group
-DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Je-li zakázat, ""zaokrouhlí celková"" pole nebude viditelný v jakékoli transakce"
-DocType: BOM,Operating Cost,Provozní náklady
-,Gross Profit,Hrubý Zisk
-DocType: Production Planning Tool,Material Requirement,Materiál Požadavek
-DocType: Company,Delete Company Transactions,Smazat transakcí Company
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +80,Item {0} is not Purchase Item,Položka {0} není Nákup položky
-apps/erpnext/erpnext/controllers/recurring_document.py +187,"{0} is an invalid email address in 'Notification \
+Purchase Invoice {0} is already submitted,Přijatá faktura {0} je již odeslána,
+Convert to non-Group,Převést na non-Group,
+Purchase Receipt must be submitted,Příjmka musí být odeslána,
+Current Stock UOM,Current Reklamní UOM,
+Batch (lot) of an Item.,Batch (lot) položky.
+Invoice Date,Datum Fakturace,
+"As there are existing stock transactions for this item, you can not change the values of 'Has Serial No', 'Has Batch No', 'Is Stock Item' and 'Valuation Method'","Jelikož jsou stávající skladové transakce za tuto položku, nelze změnit hodnoty ""Má pořadové číslo"", ""má Batch ne"", ""Je skladem"" a ""oceňování metoda"""
+Your email address,Vaše e-mailová adresa,
+Income booked for the digest period,Příjmy žlutou kartu za období digest,
+Supplier master.,Dodavatel master.
+Please see attachment,"Prosím, viz příloha"
+% Received,% Přijatm,
+Water jet cutting,Řezání vodním paprskem,
+Setup Already Complete!!,Setup již dokončen !!
+Finished Goods,Hotové zbože,
+Instructions,Instrukce,
+Inspected By,Zkontrolován,
+Maintenance Type,Typ Maintenance,
+Serial No {0} does not belong to Delivery Note {1},Pořadové číslo {0} není součástí dodávky Poznámka: {1}
+Item Quality Inspection Parameter,Položka Kontrola jakosti Parametr,
+Leave Approver Name,Nechte schvalovač Jméno,
+Schedule Date,Plán Datum,
+Packed Item,Zabalená položka,
+Default settings for buying transactions.,Výchozí nastavení pro nákup transakcí.
+Activity Cost exists for Employee {0} against Activity Type - {1},Existuje Náklady aktivity pro zaměstnance {0} proti Typ aktivity - {1}
+Please do NOT create Accounts for Customers and Suppliers. They are created directly from the Customer / Supplier masters.,"Prosím, ne vytvářet účty pro zákazníky a dodavateli. Jsou vytvořeny přímo od zákazníka / dodavatele mistrů."
+Currency Exchange,Směnárna,
+Item Name,Název položky,
+Credit Balance,Credit Balance,
+Widowed,Ovdověla,
+"Items to be requested which are ""Out of Stock"" considering all warehouses based on projected qty and minimum order qty","Položky, které je třeba požádat, které jsou ""Není skladem"" s ohledem na veškeré sklady na základě předpokládaného Množství a minimální Objednané množství"
+Working Hours,Pracovní doba,
+Change the starting / current sequence number of an existing series.,Změnit výchozí / aktuální pořadové číslo existujícího série.
+"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Je-li více pravidla pro tvorbu cen i nadále přednost, jsou uživatelé vyzváni k nastavení priority pro vyřešení konfliktu."
+Purchase Return,Nákup Return,
+Purchase Register,Nákup Register,
+"Selecting ""Yes"" will allow this item to figure in Sales Order, Delivery Note","Výběr ""Ano"" umožní tato položka přijít na odběratele, dodací list"
+Please enter Purchase Receipt No to proceed,Zadejte prosím doklad o koupi No pokračovat,
+Applicable Charges,Použitelné Poplatky,
+Consumable Cost,Spotřební Cost,
+{0} ({1}) must have role 'Leave Approver',"{0} ({1}), musí mít roli ""Schvalovatel dovolených"""
+Medical,Lékařsky,
+Reason for losing,Důvod ztráty,
+Tube beading,Tube navlékání korálky,
+Workstation is closed on the following dates as per Holiday List: {0},Workstation je uzavřena v následujících dnech podle Prázdninový Seznam: {0}
+Make Maint. Schedule,Proveďte údržba. Plán,
+Single,Jednolůžkovn,
+Cost of Goods Sold,Náklady na prodej zbožn,
+Yearly,Ročnn,
+Please enter Cost Center,"Prosím, zadejte nákladové středisko"
+Sales Order,Prodejní objednávky,
+Avg. Selling Rate,Avg. Prodej Rate,
+Start date of current order's period,Datum období současného objednávky Začátek,
+Quantity cannot be a fraction in row {0},Množství nemůže být zlomek na řádku {0}
+Quantity and Rate,Množství a cena,
+% Installed,% Instalováno,
+Please enter company name first,"Prosím, zadejte nejprve název společnosti"
+Item Desription,Položka Desription,
+Supplier Name,Dodavatel Name,
+Is Group,Is Group,
+Thermoforming,Tvarovánn,
+Slitting,Kotoučovn,
+'To Case No.' cannot be less than 'From Case No.',"""DO Případu č ' nesmí být menší než ""Od Případu č '"
+Non Profit,Non Profit,
+Not Started,Nezahájeno,
+Channel Partner,Channel Partner,
+Old Parent,Staré nadřazent,
+Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,"Přizpůsobte si úvodní text, který jede jako součást tohoto e-mailu. Každá transakce je samostatný úvodní text."
+Sales Master Manager,Sales manažer ve skupině Master,
+Global settings for all manufacturing processes.,Globální nastavení pro všechny výrobní procesy.
+Accounts Frozen Upto,Účty Frozen aa,
+Sent On,Poslán na,
+Not Applicable,Nehodí se,
+Holiday master.,Holiday master.
+Shell molding,Shell lita,
+Required Date,Požadovaná data,
+Billing Address,Fakturační adresa,
+Please enter Item Code.,"Prosím, zadejte kód položky."
+Costing,Rozpočet,
+"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Je-li zaškrtnuto, bude částka daně považovat za již zahrnuty v tisku Rate / Tisk Částka"
+Total Qty,Celkem Množstvy,
+Health Concerns,Zdravotní Obavy,
+Unpaid,Nezaplaceny,
+From Package No.,Od č balíčku,
+Securities and Deposits,Cenné papíry a vklady,
+Imports,Importy,
+Adhesive bonding,Lepeny,
+Description of a Job Opening,Popis jednoho volných pozic,
+Attendance record.,Účast rekord.
+Journal Entries,Zápisy do Deníku,
+Used for Production Plan,Používá se pro výrobní plán,
+Loading...,Nahrávám...
+Password,Heslo,
+Fused deposition modeling,Nánosový modelování depozice,
+Time Between Operations (in mins),Doba mezi operací (v min)
+"Note: Backups and files are not deleted from Google Drive, you will have to delete them manually.","Poznámka: Zálohy a soubory nejsou odstraněny z Disku Google, budete muset odstranit ručně."
+Buyer of Goods and Services.,Kupující zboží a služeb.
+Accounts Payable,Účty za úplatu,
+Add Subscribers,Přidat předplatitelu,
+""" does not exists",""" Neexistuje"
+Valid Upto,Valid a$1,
+List a few of your customers. They could be organizations or individuals.,Seznam několik svých zákazníků. Ty by mohly být organizace nebo jednotlivci.
+Open Tickets,Otevřené Vstupenky,
+Direct Income,Přímý příjmy,
+Total amount of invoices received from suppliers during the digest period,Celková výše přijatých faktur od dodavatelů během období digest,
+"Can not filter based on Account, if grouped by Account","Nelze filtrovat na základě účtu, pokud seskupeny podle účtu"
+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.,"Dodací lhůta dnech je počet dní, o nichž je tato položka očekává ve skladu. Tento dnech je přitažené za vlasy v hmotné požadavku při výběru této položky."
+Administrative Officer,Správní ředitel,
+Received Or Paid,Přijaté nebo placenl,
+"Select ""Yes"" if this item is used for some internal purpose in your company.","Zvolte ""Ano"", pokud tato položka se používá pro některé interní účely ve vaší firmě."
+Difference Account,Rozdíl účtu,
+Please enter Warehouse for which Material Request will be raised,"Prosím, zadejte sklad, který bude materiál žádosti předložené"
+Additional Operating Cost,Další provozní náklady,
+Cosmetics,Kosmetika,
+Type,Typ,
+"To merge, following properties must be same for both items","Chcete-li sloučit, tyto vlastnosti musí být stejné pro obě položky"
+Email ids separated by commas.,E-mailové ID oddělené čárkami.
+Subject,Předmět,
+"Select ""Yes"" if this item represents some work like training, designing, consulting etc.","Zvolte ""Ano"", pokud je tato položka představuje nějakou práci, jako je vzdělávání, projektování, konzultace atd."
+Net Weight,Hmotnost,
+Emergency Phone,Nouzový telefon,
+Google Drive Access Allowed,Google Drive Přístup povolen,
+Serial No Warranty Expiry,Pořadové č záruční lhůty,
+Do you really want to STOP this Material Request?,Opravdu chcete zastavit tento materiál požadavek?
+Item,Položka,
+Difference (Dr - Cr),Rozdíl (Dr - Cr)
+Profit and Loss,Zisky a ztráty,
+Upcoming Calendar Events (max 10),Nadcházející Události v kalendáři (max 10)
+New UOM must NOT be of type Whole Number,New UOM NESMÍ být typu celé číslo,
+Furniture and Fixture,Nábytek,
+Rate at which Price list currency is converted to company's base currency,"Sazba, za kterou Ceník měna je převedena na společnosti základní měny"
+Account {0} does not belong to company: {1},Účet {0} nepatří k firmě: {1}
+Default Customer Group,Výchozí Customer Group,
+"If disable, 'Rounded Total' field will not be visible in any transaction","Je-li zakázat, ""zaokrouhlí celková"" pole nebude viditelný v jakékoli transakce"
+Operating Cost,Provozní náklady,
+Gross Profit,Hrubý Zisk,
+Material Requirement,Materiál Požadavek,
+Delete Company Transactions,Smazat transakcí Company,
+Item {0} is not Purchase Item,Položka {0} není Nákup položky,
+"{0} is an invalid email address in 'Notification \
 					Email Address'","{0} je neplatná e-mailová adresa v ""Oznámení \
  E-mailová adresa"""
-apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +44,Total Billing This Year:,Celkem Billing Tento rok:
-DocType: Purchase Receipt,Add / Edit Taxes and Charges,Přidat / Upravit daní a poplatků
-DocType: Purchase Invoice,Supplier Invoice No,Dodavatelské faktury č
-DocType: Territory,For reference,Pro srovnání
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +198,Closing (Cr),Uzavření (Cr)
-DocType: Serial No,Warranty Period (Days),Záruční doba (dny)
-DocType: Installation Note Item,Installation Note Item,Poznámka k instalaci bod
-DocType: Job Applicant,Thread HTML,Thread HTML
-DocType: Company,Ignore,Ignorovat
-DocType: Backup Manager,Enter Verification Code,Zadejte ověřovací kód
-apps/erpnext/erpnext/controllers/buying_controller.py +136,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dodavatel Warehouse povinné pro subdodavatelskou doklad o zakoupení
-DocType: Pricing Rule,Valid From,Platnost od
-DocType: Sales Invoice,Total Commission,Celkem Komise
-DocType: Pricing Rule,Sales Partner,Sales Partner
-DocType: Buying Settings,Purchase Receipt Required,Příjmka je vyžadována
-DocType: Monthly Distribution,"**Monthly Distribution** helps you distribute your budget across months if you have seasonality in your business.
+Total Billing This Year:,Celkem Billing Tento rok:
+Add / Edit Taxes and Charges,Přidat / Upravit daní a poplatk$1,
+Supplier Invoice No,Dodavatelské faktury $1,
+For reference,Pro srovnán$1,
+Closing (Cr),Uzavření (Cr)
+Warranty Period (Days),Záruční doba (dny)
+Installation Note Item,Poznámka k instalaci bod,
+Thread HTML,Thread HTML,
+Ignore,Ignorovat,
+Enter Verification Code,Zadejte ověřovací kód,
+Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dodavatel Warehouse povinné pro subdodavatelskou doklad o zakoupend,
+Valid From,Platnost od,
+Total Commission,Celkem Komise,
+Sales Partner,Sales Partner,
+Purchase Receipt Required,Příjmka je vyžadována,
+"**Monthly Distribution** helps you distribute your budget across months if you have seasonality in your business.
 
 To distribute a budget using this distribution, set this **Monthly Distribution** in the **Cost Center**","** Měsíční rozložení** vám pomůže váš rozpočet distribuovat do více měsíců, pokud Vaše podnikání ovlivňuje sezónnost.
 
  Chcete-li distribuovat rozpočet pomocí tohoto rozdělení, nastavte toto ** měsíční rozložení ** v ** nákladovém středisku **"
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +172,No records found in the Invoice table,Nalezené v tabulce faktury Žádné záznamy
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +20,Please select Company and Party Type first,Vyberte první společnost a Party Typ
-apps/erpnext/erpnext/config/accounts.py +79,Financial / accounting year.,Finanční / Účetní rok.
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +172,"Sorry, Serial Nos cannot be merged","Je nám líto, sériových čísel nelze sloučit"
-DocType: Email Digest,New Supplier Quotations,Nového dodavatele Citace
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +616,Make Sales Order,Ujistěte se prodejní objednávky
-DocType: Project Task,Project Task,Úkol Project
-,Lead Id,Olovo Id
-DocType: C-Form Invoice Detail,Grand Total,Celkem
-DocType: About Us Settings,Website Manager,Správce webu
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Datum zahájení Fiskálního roku by nemělo být větší než datum ukončení
-DocType: Warranty Claim,Resolution,Řešení
-DocType: Sales Order,Display all the individual items delivered with the main items,Zobrazit všechny jednotlivé položky dodané s hlavními položkami
-apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +67,Payable Account,Splatnost účtu
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Opakujte zákazníci
-DocType: Backup Manager,Sync with Google Drive,Synchronizace s Google Disku
-DocType: Leave Control Panel,Allocate,Přidělit
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard_page.html +16,Previous,Předchozí
-DocType: Stock Entry,Sales Return,Sales Return
-DocType: Production Planning Tool,Select Sales Orders from which you want to create Production Orders.,"Vyberte prodejní objednávky, ze kterého chcete vytvořit výrobní zakázky."
-apps/erpnext/erpnext/config/hr.py +120,Salary components.,Mzdové složky.
-apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,Databáze potenciálních zákazníků.
-apps/erpnext/erpnext/config/crm.py +17,Customer database.,Databáze zákazníků.
-DocType: Quotation,Quotation To,Nabídka k
-DocType: Lead,Middle Income,Středními příjmy
-apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +58,Opening (Cr),Otvor (Cr)
-apps/erpnext/erpnext/accounts/utils.py +186,Allocated amount can not be negative,Přidělená částka nemůže být záporná
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +122,Tumbling,Tumbling
-DocType: Purchase Order Item,Billed Amt,Účtovaného Amt
-DocType: Warehouse,A logical Warehouse against which stock entries are made.,"Logická Warehouse na položky, které mohou být vyrobeny."
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +111,Reference No & Reference Date is required for {0},Referenční číslo a referenční datum je nutné pro {0}
-DocType: Event,Wednesday,Středa
-DocType: Sales Invoice,Customer's Vendor,Prodejce zákazníka
-apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +197,Production Order is Mandatory,Výrobní zakázka je povinné
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +40,{0} {1} has a common territory {2},{0} {1} má společný území {2}
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +134,Proposal Writing,Návrh Psaní
-apps/erpnext/erpnext/config/setup.py +85,Masters,Masters
-apps/erpnext/erpnext/stock/stock_ledger.py +316,Negative Stock Error ({6}) for Item {0} in Warehouse {1} on {2} {3} in {4} {5},Negativní Sklad Error ({6}) k bodu {0} ve skladu {1} na {2} {3} v {4} {5}
-DocType: Fiscal Year Company,Fiscal Year Company,Fiskální rok Společnosti
-DocType: Packing Slip Item,DN Detail,DN Detail
-DocType: Time Log,Billed,Fakturováno
-DocType: Batch,Batch Description,Popis Šarže
-DocType: Delivery Note,Time at which items were delivered from warehouse,"Čas, kdy byly předměty dodány od skladu"
-DocType: Sales Invoice,Sales Taxes and Charges,Prodej Daně a poplatky
-DocType: Employee,Organization Profile,Profil organizace
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +90,Please setup numbering series for Attendance via Setup > Numbering Series,"Prosím, nastavení číslování série pro Účast přes Nastavení> Série číslování"
-DocType: Email Digest,New Enquiries,Nové Dotazy
-DocType: Employee,Reason for Resignation,Důvod rezignace
-apps/erpnext/erpnext/config/hr.py +150,Template for performance appraisals.,Šablona pro hodnocení výkonu.
-DocType: Payment Reconciliation,Invoice/Journal Entry Details,Faktura / Zápis do deníku Podrobnosti
-apps/erpnext/erpnext/accounts/utils.py +50,{0} '{1}' not in Fiscal Year {2},{0} '{1}' není v fiskálním roce {2}
-DocType: Buying Settings,Settings for Buying Module,Nastavení pro nákup modul
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +62,Please enter Purchase Receipt first,"Prosím, zadejte první doklad o zakoupení"
-DocType: Buying Settings,Supplier Naming By,Dodavatel Pojmenování By
-DocType: Maintenance Schedule,Maintenance Schedule,Plán údržby
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +34,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Pak se pravidla pro tvorbu cen jsou odfiltrovány založeny na zákazníka, skupiny zákazníků, území, dodavatel, dodavatel typ, kampaň, obchodní partner atd"
-apps/erpnext/erpnext/setup/doctype/backup_manager/backup_dropbox.py +126,Please install dropbox python module,"Prosím, nainstalujte dropbox python modul"
-DocType: Employee,Passport Number,Číslo pasu
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +77,Manager,Manažer
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +512,From Purchase Receipt,Z příjemky
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +222,Same item has been entered multiple times.,Stejný bod byl zadán vícekrát.
-DocType: SMS Settings,Receiver Parameter,Přijímač parametrů
-apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,"""Založeno Na"" a ""Seskupeno Podle"", nemůže být stejné"
-DocType: Sales Person,Sales Person Targets,Obchodník cíle
-sites/assets/js/form.min.js +253,To,na
-apps/erpnext/erpnext/templates/includes/footer_extension.html +39,Please enter email address,Zadejte e-mailovou adresu
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +34,End tube forming,Konec trubice tvořící
-DocType: Production Order Operation,In minutes,V minutách
-DocType: Issue,Resolution Date,Rozlišení Datum
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +596,Please set default Cash or Bank account in Mode of Payment {0},Prosím nastavte výchozí v hotovosti nebo bankovním účtu v způsob platby {0}
-DocType: Selling Settings,Customer Naming By,Zákazník Pojmenování By
-apps/erpnext/erpnext/accounts/doctype/account/account.js +67,Convert to Group,Převést do skupiny
-DocType: Activity Cost,Activity Type,Druh činnosti
-apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,Dodává Částka
-DocType: Sales Invoice,Packing List,Balení Seznam
-apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Nákupní Objednávky odeslané Dodavatelům.
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +42,Publishing,Publikování
-DocType: Activity Cost,Projects User,Projekty uživatele
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,Spotřeba
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +187,{0}: {1} not found in Invoice Details table,{0}: {1} nebyla nalezena v tabulce Podrobnosti Faktury
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +189,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Údržba Navštivte {0} musí být zrušena před zrušením této prodejní objednávky
-DocType: Material Request,Material Transfer,Přesun materiálu
-apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +56,Opening (Dr),Opening (Dr)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +406,Posting timestamp must be after {0},Časová značka zadání musí být po {0}
-apps/frappe/frappe/config/setup.py +59,Settings,Nastavení
-DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Přistál nákladů daně a poplatky
-DocType: Production Order Operation,Actual Start Time,Skutečný čas začátku
-DocType: BOM Operation,Operation Time,Provozní doba
-sites/assets/js/list.min.js +5,More,Více
-DocType: Communication,Sales Manager,Manažer prodeje
-sites/assets/js/desk.min.js +555,Rename,Přejmenovat
-DocType: Purchase Invoice,Write Off Amount,Odepsat Částka
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +51,Bending,Ohýbání
-DocType: Leave Block List Allow,Allow User,Umožňuje uživateli
-DocType: Journal Entry,Bill No,Bill No
-DocType: Purchase Invoice,Quarterly,Čtvrtletně
-DocType: Selling Settings,Delivery Note Required,Delivery Note Povinné
-DocType: Sales Order Item,Basic Rate (Company Currency),Basic Rate (Company měny)
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +66,Please enter item details,"Prosím, zadejte podrobnosti položky"
-DocType: Purchase Receipt,Other Details,Další podrobnosti
-DocType: Account,Accounts,Účty
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +62,Marketing,Marketing
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +64,Straight shearing,Straight stříhání
-DocType: Features Setup,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.,Chcete-li sledovat položky v oblasti prodeje a nákupu dokumentů na základě jejich sériových čísel. To je možné také použít ke sledování detailů produktu záruční.
-DocType: Purchase Receipt Item Supplied,Current Stock,Current skladem
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +81,Rejected Warehouse is mandatory against regected item,Zamítnuto Warehouse je povinná proti regected položky
-DocType: Account,Expenses Included In Valuation,Náklady ceně oceňování
-DocType: Employee,Provide email id registered in company,Poskytnout e-mail id zapsané ve firmě
-DocType: Hub Settings,Seller City,Prodejce City
-DocType: Email Digest,Next email will be sent on:,Další e-mail bude odeslán dne:
-DocType: Offer Letter Term,Offer Letter Term,Nabídka Letter Term
-apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +23,Item {0} not found,Položka {0} nebyl nalezen
-DocType: Bin,Stock Value,Reklamní Value
-apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +88,Tree Type,Tree Type
-DocType: BOM Explosion Item,Qty Consumed Per Unit,Množství spotřebované na jednotku
-DocType: Serial No,Warranty Expiry Date,Záruka Datum vypršení platnosti
-DocType: Material Request Item,Quantity and Warehouse,Množství a sklad
-DocType: Sales Invoice,Commission Rate (%),Výše provize (%)
-apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +141,"Against Voucher Type must be one of Sales Order, Sales Invoice or Journal Entry","Proti poukazu Type musí být jedním z prodejní objednávky, prodejní faktury nebo Journal Entry"
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +138,Biomachining,Biomachining
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +6,Aerospace,Aerospace
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +19,Welcome,Vítejte
-DocType: Journal Entry,Credit Card Entry,Vstup Kreditní karta
-apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +18,Task Subject,Úkol Předmět
-apps/erpnext/erpnext/config/stock.py +28,Goods received from Suppliers.,Zboží od dodavatelů.
-DocType: Communication,Open,Otevřít
-DocType: Lead,Campaign Name,Název kampaně
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +197,Please enter Delivery Note No or Sales Invoice No to proceed,"Prosím, zadejte dodacího listu nebo prodejní faktury č pokračovat"
-,Reserved,Rezervováno
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +650,Do you really want to UNSTOP,"Opravdu chcete, aby uvolnit"
-DocType: Purchase Order,Supply Raw Materials,Dodávek surovin
-DocType: Purchase Invoice,The date on which next invoice will be generated. It is generated on submit.,"Datum, kdy bude vygenerován příští faktury. To je generován na odeslat."
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Oběžná aktiva
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +108,{0} is not a stock Item,{0} není skladová položka
-DocType: Mode of Payment Account,Default Account,Výchozí účet
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +155,Lead must be set if Opportunity is made from Lead,Vedoucí musí být nastavena pokud Opportunity je vyrobena z olova
-DocType: Contact Us Settings,Address Title,Označení adresy
-apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +32,Please select weekly off day,"Prosím, vyberte týdenní off den"
-DocType: Production Order Operation,Planned End Time,Plánované End Time
-,Sales Person Target Variance Item Group-Wise,Prodej Osoba Cílová Odchylka Item Group-Wise
-DocType: Backup Manager,Daily,Denně
-apps/erpnext/erpnext/accounts/doctype/account/account.py +79,Account with existing transaction cannot be converted to ledger,Účet s transakcemi nelze převést na hlavní účetní knihu
-DocType: Delivery Note,Customer's Purchase Order No,Zákazníka Objednávka No
-DocType: Employee,Cell Number,Číslo buňky
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,Ztracený
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +139,You can not enter current voucher in 'Against Journal Entry' column,"Nelze zadat aktuální poukaz v ""Proti Zápis do deníku"" sloupci"
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +24,Energy,Energie
-DocType: Opportunity,Opportunity From,Příležitost Z
-apps/erpnext/erpnext/config/hr.py +33,Monthly salary statement.,Měsíční plat prohlášení.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +434,"Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. \
+No records found in the Invoice table,Nalezené v tabulce faktury Žádné záznamy,
+Please select Company and Party Type first,Vyberte první společnost a Party Typ,
+Financial / accounting year.,Finanční / Účetní rok.
+"Sorry, Serial Nos cannot be merged","Je nám líto, sériových čísel nelze sloučit"
+New Supplier Quotations,Nového dodavatele Citace,
+Make Sales Order,Ujistěte se prodejní objednávky,
+Project Task,Úkol Project,
+Lead Id,Olovo Id,
+Grand Total,Celkem,
+Website Manager,Správce webu,
+Fiscal Year Start Date should not be greater than Fiscal Year End Date,Datum zahájení Fiskálního roku by nemělo být větší než datum ukončene,
+Resolution,Řešene,
+Display all the individual items delivered with the main items,Zobrazit všechny jednotlivé položky dodané s hlavními položkami,
+Payable Account,Splatnost účtu,
+Repeat Customers,Opakujte zákazníci,
+Sync with Google Drive,Synchronizace s Google Disku,
+Allocate,Přidělit,
+Previous,Předchoze,
+Sales Return,Sales Return,
+Select Sales Orders from which you want to create Production Orders.,"Vyberte prodejní objednávky, ze kterého chcete vytvořit výrobní zakázky."
+Salary components.,Mzdové složky.
+Database of potential customers.,Databáze potenciálních zákazníků.
+Customer database.,Databáze zákazníků.
+Quotation To,Nabídka k,
+Middle Income,Středními příjmy,
+Opening (Cr),Otvor (Cr)
+Allocated amount can not be negative,Přidělená částka nemůže být záporng,
+Tumbling,Tumbling,
+Billed Amt,Účtovaného Amt,
+A logical Warehouse against which stock entries are made.,"Logická Warehouse na položky, které mohou být vyrobeny."
+Reference No & Reference Date is required for {0},Referenční číslo a referenční datum je nutné pro {0}
+Wednesday,Středa,
+Customer's Vendor,Prodejce zákazníka,
+Production Order is Mandatory,Výrobní zakázka je povinna,
+{0} {1} has a common territory {2},{0} {1} má společný území {2}
+Proposal Writing,Návrh Psans,
+Masters,Masters,
+Negative Stock Error ({6}) for Item {0} in Warehouse {1} on {2} {3} in {4} {5},Negativní Sklad Error ({6}) k bodu {0} ve skladu {1} na {2} {3} v {4} {5}
+Fiscal Year Company,Fiskální rok Společnosti,
+DN Detail,DN Detail,
+Billed,Fakturováno,
+Batch Description,Popis Šarže,
+Time at which items were delivered from warehouse,"Čas, kdy byly předměty dodány od skladu"
+Sales Taxes and Charges,Prodej Daně a poplatky,
+Organization Profile,Profil organizace,
+Please setup numbering series for Attendance via Setup > Numbering Series,"Prosím, nastavení číslování série pro Účast přes Nastavení> Série číslování"
+New Enquiries,Nové Dotazy,
+Reason for Resignation,Důvod rezignace,
+Template for performance appraisals.,Šablona pro hodnocení výkonu.
+Invoice/Journal Entry Details,Faktura / Zápis do deníku Podrobnosti,
+{0} '{1}' not in Fiscal Year {2},{0} '{1}' není v fiskálním roce {2}
+Settings for Buying Module,Nastavení pro nákup modul,
+Please enter Purchase Receipt first,"Prosím, zadejte první doklad o zakoupení"
+Supplier Naming By,Dodavatel Pojmenování By,
+Maintenance Schedule,Plán údržby,
+"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Pak se pravidla pro tvorbu cen jsou odfiltrovány založeny na zákazníka, skupiny zákazníků, území, dodavatel, dodavatel typ, kampaň, obchodní partner atd"
+Please install dropbox python module,"Prosím, nainstalujte dropbox python modul"
+Passport Number,Číslo pasu,
+Manager,Manažer,
+From Purchase Receipt,Z příjemky,
+Same item has been entered multiple times.,Stejný bod byl zadán vícekrát.
+Receiver Parameter,Přijímač parametr$1,
+'Based On' and 'Group By' can not be same,"""Založeno Na"" a ""Seskupeno Podle"", nemůže být stejné"
+Sales Person Targets,Obchodník cíle,
+To,na,
+Please enter email address,Zadejte e-mailovou adresu,
+End tube forming,Konec trubice tvoříce,
+In minutes,V minutách,
+Resolution Date,Rozlišení Datum,
+Please set default Cash or Bank account in Mode of Payment {0},Prosím nastavte výchozí v hotovosti nebo bankovním účtu v způsob platby {0}
+Customer Naming By,Zákazník Pojmenování By,
+Convert to Group,Převést do skupiny,
+Activity Type,Druh činnosti,
+Delivered Amount,Dodává Částka,
+Packing List,Balení Seznam,
+Purchase Orders given to Suppliers.,Nákupní Objednávky odeslané Dodavatelům.
+Publishing,Publikováne,
+Projects User,Projekty uživatele,
+Consumed,Spotřeba,
+{0}: {1} not found in Invoice Details table,{0}: {1} nebyla nalezena v tabulce Podrobnosti Faktury,
+Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Údržba Navštivte {0} musí být zrušena před zrušením této prodejní objednávky,
+Material Transfer,Přesun materiálu,
+Opening (Dr),Opening (Dr)
+Posting timestamp must be after {0},Časová značka zadání musí být po {0}
+Settings,Nastaveny,
+Landed Cost Taxes and Charges,Přistál nákladů daně a poplatky,
+Actual Start Time,Skutečný čas začátku,
+Operation Time,Provozní doba,
+More,Více,
+Sales Manager,Manažer prodeje,
+Rename,Přejmenovat,
+Write Off Amount,Odepsat Částka,
+Bending,Ohýbány,
+Allow User,Umožňuje uživateli,
+Bill No,Bill No,
+Quarterly,Čtvrtletny,
+Delivery Note Required,Delivery Note Povinny,
+Basic Rate (Company Currency),Basic Rate (Company měny)
+Please enter item details,"Prosím, zadejte podrobnosti položky"
+Other Details,Další podrobnosti,
+Accounts,Účty,
+Marketing,Marketing,
+Straight shearing,Straight stříháni,
+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.,Chcete-li sledovat položky v oblasti prodeje a nákupu dokumentů na základě jejich sériových čísel. To je možné také použít ke sledování detailů produktu záruční.
+Current Stock,Current skladem,
+Rejected Warehouse is mandatory against regected item,Zamítnuto Warehouse je povinná proti regected položky,
+Expenses Included In Valuation,Náklady ceně oceňovánm,
+Provide email id registered in company,Poskytnout e-mail id zapsané ve firmm,
+Seller City,Prodejce City,
+Next email will be sent on:,Další e-mail bude odeslán dne:
+Offer Letter Term,Nabídka Letter Term,
+Item {0} not found,Položka {0} nebyl nalezen,
+Stock Value,Reklamní Value,
+Tree Type,Tree Type,
+Qty Consumed Per Unit,Množství spotřebované na jednotku,
+Warranty Expiry Date,Záruka Datum vypršení platnosti,
+Quantity and Warehouse,Množství a sklad,
+Commission Rate (%),Výše provize (%)
+"Against Voucher Type must be one of Sales Order, Sales Invoice or Journal Entry","Proti poukazu Type musí být jedním z prodejní objednávky, prodejní faktury nebo Journal Entry"
+Biomachining,Biomachining,
+Aerospace,Aerospace,
+Welcome,Vítejte,
+Credit Card Entry,Vstup Kreditní karta,
+Task Subject,Úkol Předmět,
+Goods received from Suppliers.,Zboží od dodavatelů.
+Open,Otevřít,
+Campaign Name,Název kampant,
+Please enter Delivery Note No or Sales Invoice No to proceed,"Prosím, zadejte dodacího listu nebo prodejní faktury č pokračovat"
+Reserved,Rezervováno,
+Do you really want to UNSTOP,"Opravdu chcete, aby uvolnit"
+Supply Raw Materials,Dodávek surovin,
+The date on which next invoice will be generated. It is generated on submit.,"Datum, kdy bude vygenerován příští faktury. To je generován na odeslat."
+Current Assets,Oběžná aktiva,
+{0} is not a stock Item,{0} není skladová položka,
+Default Account,Výchozí účet,
+Lead must be set if Opportunity is made from Lead,Vedoucí musí být nastavena pokud Opportunity je vyrobena z olova,
+Address Title,Označení adresy,
+Please select weekly off day,"Prosím, vyberte týdenní off den"
+Planned End Time,Plánované End Time,
+Sales Person Target Variance Item Group-Wise,Prodej Osoba Cílová Odchylka Item Group-Wise,
+Daily,Denne,
+Account with existing transaction cannot be converted to ledger,Účet s transakcemi nelze převést na hlavní účetní knihu,
+Customer's Purchase Order No,Zákazníka Objednávka No,
+Cell Number,Číslo buňky,
+Lost,Ztracene,
+You can not enter current voucher in 'Against Journal Entry' column,"Nelze zadat aktuální poukaz v ""Proti Zápis do deníku"" sloupci"
+Energy,Energie,
+Opportunity From,Příležitost Z,
+Monthly salary statement.,Měsíční plat prohlášení.
+"Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. \
 						Pending Amount is {2}","Řádek č {0}: Částka nesmí být větší než Až do částky proti Expense nároku {1}. \
  Až Částka je {2}"
-DocType: Item Group,Website Specifications,Webových stránek Specifikace
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +198,New Account,Nový účet
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +21,{0}: From {0} of type {1},{0}: Od {0} typu {1}
-apps/erpnext/erpnext/controllers/buying_controller.py +284,Row {0}: Conversion Factor is mandatory,Row {0}: Konverzní faktor je povinné
-apps/erpnext/erpnext/templates/pages/ticket.py +27,Please write something,Napište něco
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +27,Accounting Entries can be made against leaf nodes. Entries against Groups are not allowed.,Účetní Přihlášky lze proti koncové uzly. Záznamy proti skupinám nejsou povoleny.
-DocType: ToDo,High,Vysoké
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +364,Cannot deactivate or cancel BOM as it is linked with other BOMs,"Nelze deaktivovat nebo zrušit BOM, jak to souvisí s ostatními kusovníky"
-DocType: Opportunity,Maintenance,Údržba
-DocType: User,Male,Muž
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +181,Purchase Receipt number required for Item {0},Číslo příjmky je potřeba pro položku {0}
-DocType: Item Attribute Value,Item Attribute Value,Položka Hodnota atributu
-apps/erpnext/erpnext/config/crm.py +54,Sales campaigns.,Prodej kampaně.
-DocType: Sales Taxes and Charges Template,"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
+Website Specifications,Webových stránek Specifikace,
+New Account,Nový účet,
+{0}: From {0} of type {1},{0}: Od {0} typu {1}
+Row {0}: Conversion Factor is mandatory,Row {0}: Konverzní faktor je povinno,
+Please write something,Napište něco,
+Accounting Entries can be made against leaf nodes. Entries against Groups are not allowed.,Účetní Přihlášky lze proti koncové uzly. Záznamy proti skupinám nejsou povoleny.
+High,Vysok$1,
+Cannot deactivate or cancel BOM as it is linked with other BOMs,"Nelze deaktivovat nebo zrušit BOM, jak to souvisí s ostatními kusovníky"
+Maintenance,Údržba,
+Male,Mua,
+Purchase Receipt number required for Item {0},Číslo příjmky je potřeba pro položku {0}
+Item Attribute Value,Položka Hodnota atributu,
+Sales campaigns.,Prodej kampaně.
+"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
 
-#### Note
+#### Note,
 
 The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.
 
-#### Description of Columns
+#### Description of Columns,
 
 1. Calculation Type: 
     - This can be on **Net Total** (that is the sum of basic amount).
     - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
     - **Actual** (as mentioned).
-2. Account Head: The Account ledger under which this tax will be booked
+2. Account Head: The Account ledger under which this tax will be booked,
 3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
 4. Description: Description of the tax (that will be printed in invoices / quotes).
 5. Rate: Tax rate.
@@ -707,208 +707,208 @@
  7. Celkem: Kumulativní celková k tomuto bodu.
  8. Zadejte Row: Je-li na základě ""předchozí řady Total"" můžete zvolit číslo řádku, která bude přijata jako základ pro tento výpočet (výchozí je předchozí řádek).
  9. Je to poplatek v ceně do základní sazby ?: Pokud se to ověřit, znamená to, že tato daň nebude zobrazen pod tabulkou položky, ale budou zahrnuty do základní sazby v hlavním položce tabulky. To je užitečné, pokud chcete dát paušální cenu (včetně všech poplatků), ceny pro zákazníky."
-DocType: Serial No,Purchase Returned,Nákup Vráceno
-DocType: Employee,Bank A/C No.,"Č, bank. účtu"
-DocType: Email Digest,Scheduler Failed Events,Plánovač Nepodařilo Events
-DocType: Expense Claim,Project,Projekt
-DocType: Quality Inspection Reading,Reading 7,Čtení 7
-DocType: Address,Personal,Osobní
-DocType: Expense Claim Detail,Expense Claim Type,Náklady na pojistná Type
-DocType: Shopping Cart Settings,Default settings for Shopping Cart,Výchozí nastavení Košík
-apps/erpnext/erpnext/controllers/accounts_controller.py +255,"Journal Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Zápis do deníku {0} je spojen proti řádu {1}, zkontrolujte, zda by měl být tažen za pokrok v této faktuře."
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +12,Biotechnology,Biotechnologie
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +108,Office Maintenance Expenses,Náklady Office údržby
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +52,Hemming,Hemming
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +64,Please enter Item first,"Prosím, nejdřív zadejte položku"
-DocType: Account,Liability,Odpovědnost
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +61,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankcionována Částka nemůže být větší než reklamace Částka v řádku {0}.
-DocType: Company,Default Cost of Goods Sold Account,Výchozí Náklady na prodané zboží účtu
-apps/erpnext/erpnext/stock/get_item_details.py +238,Price List not selected,Ceník není zvolen
-DocType: Employee,Family Background,Rodinné poměry
-DocType: Salary Manager,Send Email,Odeslat email
-apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +85,No Permission,Nemáte oprávnění
-DocType: Company,Default Bank Account,Výchozí Bankovní účet
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +43,"To filter based on Party, select Party Type first","Chcete-li filtrovat na základě Party, vyberte typ Party první"
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +574,Nos,Nos
-DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Bank Odsouhlasení Detail
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +588,My Invoices,Moje Faktury
-apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +39,No employee found,Žádný zaměstnanec nalezeno
-DocType: Purchase Order,Stopped,Zastaveno
-DocType: SMS Center,All Customer Contact,Vše Kontakt Zákazník
-apps/erpnext/erpnext/config/stock.py +64,Upload stock balance via csv.,Nahrát nutnosti rovnováhy prostřednictvím CSV.
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +32,Send Now,Odeslat nyní
-,Support Analytics,Podpora Analytics
-DocType: Item,Website Warehouse,Sklad pro web
-DocType: Sales Invoice,"The day of the month on which auto invoice will be generated e.g. 05, 28 etc","Den měsíce, ve kterém auto faktura bude generován například 05, 28 atd"
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49,Score must be less than or equal to 5,Skóre musí být menší než nebo rovna 5
-apps/erpnext/erpnext/config/accounts.py +159,C-Form records,C-Form záznamy
-DocType: Email Digest,Email Digest Settings,Nastavení e-mailu Digest
-apps/erpnext/erpnext/config/support.py +13,Support queries from customers.,Podpora dotazy ze strany zákazníků.
-DocType: Bin,Moving Average Rate,Klouzavý průměr
-DocType: Production Planning Tool,Select Items,Vyberte položky
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +294,{0} against Bill {1} dated {2},{0} proti účtu {1} ze dne {2}
-DocType: Communication,Reference Name,Název reference
-DocType: Maintenance Visit,Completion Status,Dokončení Status
-DocType: Features Setup,"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","Chcete-li sledovat značku v těchto dokumentech dodacího listu Opportunity, materiál Request, bod, objednávky, nákup poukazu, nakupují stvrzenka, cenovou nabídku, prodejní faktury, Sales BOM, prodejní objednávky, pořadové číslo"
-DocType: Production Order,Target Warehouse,Target Warehouse
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +23,Expected Delivery Date cannot be before Sales Order Date,"Očekávané datum dodání, nemůže být před Sales pořadí Datum"
-DocType: Upload Attendance,Import Attendance,Importovat Docházku
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +17,All Item Groups,Všechny skupiny položek
-DocType: Salary Manager,Activity Log,Aktivita Log
-apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +30,Net Profit / Loss,Čistý zisk / ztráta
-apps/erpnext/erpnext/config/setup.py +64,Automatically compose message on submission of transactions.,Automaticky napsat vzkaz na předkládání transakcí.
-DocType: Production Order,Item To Manufacture,Bod K výrobě
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +15,Permanent mold casting,Trvalé odlévání forem
-DocType: Sales Order Item,Projected Qty,Předpokládané množství
-DocType: Sales Invoice,Payment Due Date,Splatno dne
-DocType: Newsletter,Newsletter Manager,Newsletter Manažer
-DocType: Notification Control,Delivery Note Message,Delivery Note Message
-DocType: Expense Claim,Expenses,Výdaje
-,Purchase Receipt Trends,Doklad o koupi Trendy
-DocType: Appraisal,Select template from which you want to get the Goals,"Vyberte šablonu, ze kterého chcete získat cílů"
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +72,Research & Development,Výzkum a vývoj
-,Amount to Bill,Částka k Fakturaci
-DocType: Company,Registration Details,Registrace Podrobnosti
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +74,Staking,Sázet
-DocType: Item Reorder,Re-Order Qty,Re-Order Množství
-DocType: Leave Block List Date,Leave Block List Date,Nechte Block List Datum
-apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +23,Scheduled to send to {0},Plánované poslat na {0}
-DocType: Pricing Rule,Price or Discount,Cena nebo Sleva
-DocType: Sales Team,Incentives,Pobídky
-apps/erpnext/erpnext/config/hr.py +38,Performance appraisal.,Hodnocení výkonu.
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Hodnota projektu
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +636,Make Maint. Visit,Proveďte údržba. Návštěva
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +68,Cannot carry forward {0},Nelze převést {0}
-apps/erpnext/erpnext/accounts/doctype/account/account.py +73,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Zůstatek na účtu již v Credit, není dovoleno stanovit ""Balance musí být"" jako ""debet"""
-DocType: Account,Balance must be,Zůstatek musí být
-DocType: Hub Settings,Publish Pricing,Publikovat Ceník
-DocType: Email Digest,New Purchase Receipts,Nové Nákup Příjmy
-DocType: Notification Control,Expense Claim Rejected Message,Zpráva o zamítnutí úhrady výdajů
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +144,Nailing,Báječný
-,Available Qty,Množství k dispozici
-DocType: Purchase Taxes and Charges,On Previous Row Total,Na předchozí řady Celkem
-DocType: Salary Slip,Working Days,Pracovní dny
-DocType: Serial No,Incoming Rate,Příchozí Rate
-DocType: Packing Slip,Gross Weight,Hrubá hmotnost
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +409,The name of your company for which you are setting up this system.,"Název vaší společnosti, pro kterou nastavení tohoto systému."
-DocType: HR Settings,Include holidays in Total no. of Working Days,Zahrnout dovolenou v celkovém. pracovních dní
-DocType: Job Applicant,Hold,Držet
-DocType: Employee,Date of Joining,Datum přistoupení
-DocType: Naming Series,Update Series,Řada Aktualizace
-DocType: Supplier Quotation,Is Subcontracted,Subdodavatelům
-DocType: Item Attribute,Item Attribute Values,Položka Hodnoty atributů
-apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +3,View Subscribers,Zobrazit Odběratelé
-DocType: Purchase Invoice Item,Purchase Receipt,Příjemka
-,Received Items To Be Billed,"Přijaté položek, které mají být účtovány"
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +113,Abrasive blasting,Abrazivní tryskání
-DocType: Employee,Ms,Paní
-apps/erpnext/erpnext/config/accounts.py +138,Currency exchange rate master.,Devizový kurz master.
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +242,Unable to find Time Slot in the next {0} days for Operation {1},Nelze najít časový úsek v příštích {0} dní k provozu {1}
-DocType: Production Order,Plan material for sub-assemblies,Plán materiál pro podsestavy
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +423,BOM {0} must be active,BOM {0} musí být aktivní
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.js +22,Set Status as Available,Nastavit stav as k dispozici
-apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +26,Please select the document type first,Vyberte první typ dokumentu
-apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.py +68,Cancel Material Visits {0} before cancelling this Maintenance Visit,Zrušit Materiál Návštěvy {0} před zrušením tohoto návštěv údržby
-DocType: Salary Slip,Leave Encashment Amount,Nechte inkasa Částka
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +223,Serial No {0} does not belong to Item {1},Pořadové číslo {0} nepatří k bodu {1}
-apps/erpnext/erpnext/accounts/page/pos/pos_page.html +13,Make new POS Setting,Proveďte nové nastavení POS
-DocType: Purchase Receipt Item Supplied,Required Qty,Požadované množství
-DocType: Bank Reconciliation,Total Amount,Celková částka
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +31,Internet Publishing,Internet Publishing
-DocType: Production Planning Tool,Production Orders,Výrobní Objednávky
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +30,Balance Value,Zůstatek Hodnota
-apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Sales Ceník
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +69,Publish to sync items,Publikování synchronizovat položky
-DocType: Purchase Receipt,Range,Rozsah
-DocType: Supplier,Default Payable Accounts,Výchozí úplatu účty
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +40,Employee {0} is not active or does not exist,Zaměstnanec {0} není aktivní nebo neexistuje
-DocType: Features Setup,Item Barcode,Položka Barcode
-apps/erpnext/erpnext/stock/doctype/item/item.py +193,Item Variants {0} updated,Bod Varianty {0} aktualizováno
-DocType: Quality Inspection Reading,Reading 6,Čtení 6
-DocType: Purchase Invoice Advance,Purchase Invoice Advance,Záloha přijaté faktury
-DocType: Address,Shop,Obchod
-DocType: Hub Settings,Sync Now,Sync teď
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +191,Row {0}: Credit entry can not be linked with a {1},Row {0}: Credit záznam nemůže být spojována s {1}
-DocType: Mode of Payment Account,Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,"Výchozí účet Bank / Cash budou automaticky aktualizovány v POS faktury, pokud je zvolen tento režim."
-DocType: Employee,Permanent Address Is,Trvalé bydliště je
-DocType: Production Order Operation,Operation completed for how many finished goods?,Provoz dokončeno kolika hotových výrobků?
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +471,The Brand,Brand
-apps/erpnext/erpnext/controllers/status_updater.py +123,Allowance for over-{0} crossed for Item {1}.,Příspěvek na nadměrné {0} přešel k bodu {1}.
-DocType: Employee,Exit Interview Details,Exit Rozhovor Podrobnosti
-DocType: Item,Is Purchase Item,je Nákupní Položka
-DocType: Payment Reconciliation Payment,Purchase Invoice,Přijatá faktura
-DocType: Stock Ledger Entry,Voucher Detail No,Voucher Detail No
-DocType: Stock Entry,Total Outgoing Value,Celková hodnota Odchozí
-DocType: Lead,Request for Information,Žádost o informace
-DocType: Payment Tool,Paid,Placený
-DocType: Salary Slip,Total in words,Celkem slovy
-DocType: Material Request Item,Lead Time Date,Lead Time data
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +127,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Zadejte Pořadové číslo k bodu {1}
-apps/erpnext/erpnext/config/stock.py +23,Shipments to customers.,Zásilky zákazníkům.
-DocType: Purchase Invoice Item,Purchase Order Item,Položka vydané objednávky
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +152,Indirect Income,Nepřímé příjmy
-DocType: Contact Us Settings,Address Line 1,Adresní řádek 1
-apps/erpnext/erpnext/selling/report/territory_target_variance_item_group_wise/territory_target_variance_item_group_wise.py +50,Variance,Odchylka
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +390,Company Name,Název společnosti
-DocType: SMS Center,Total Message(s),Celkem zpráv (y)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +508,Select Item for Transfer,Vybrat položku pro převod
-DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,"Vyberte účet šéf banky, kde byla uložena kontrola."
-DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Povolit uživateli upravovat Ceník Cena při transakcích
-DocType: Pricing Rule,Max Qty,Max Množství
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +125,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Row {0}: Platba na prodejní / nákupní objednávce by měly být vždy označeny jako předem
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +15,Chemical,Chemický
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +660,All items have already been transferred for this Production Order.,Všechny položky již byly převedeny na výrobu tohoto řádu.
-DocType: Salary Manager,Select Payroll Year and Month,Vyberte Payroll rok a měsíc
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +32,"Go to the appropriate group (usually Application of Funds > Current Assets > Bank Accounts and create a new Account (by clicking on Add Child) of type ""Bank""",Přejděte na příslušné skupiny (obvykle využití finančních prostředků&gt; oběžných aktiv&gt; bankovních účtů a vytvořit nový účet (kliknutím na Přidat dítě) typu &quot;Bank&quot;
-DocType: Workstation,Electricity Cost,Cena elektřiny
-DocType: HR Settings,Don't send Employee Birthday Reminders,Neposílejte zaměstnance připomenutí narozenin
-DocType: Comment,Unsubscribed,Odhlášen z odběru
-DocType: Opportunity,Walk In,Vejít
-DocType: Item,Inspection Criteria,Inspekční Kritéria
-apps/erpnext/erpnext/config/accounts.py +96,Tree of finanial Cost Centers.,Strom finanial nákladových středisek.
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +472,Upload your letter head and logo. (you can edit them later).,Nahrajte svůj dopis hlavu a logo. (Můžete je upravit později).
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +151,White,Bílá
-DocType: SMS Center,All Lead (Open),Všechny Lead (Otevřeny)
-DocType: Purchase Invoice,Get Advances Paid,Získejte zaplacené zálohy
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +360,Attach Your Picture,Připojit svůj obrázek
-DocType: Journal Entry,Total Amount in Words,Celková částka slovy
-DocType: Workflow State,Stop,Stop
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7,There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,"Došlo k chybě. Jedním z důvodů by mohlo být pravděpodobné, že jste uložili formulář. Obraťte se prosím na support@erpnext.com Pokud problém přetrvává."
-DocType: Purchase Order,% of materials billed against this Purchase Order.,% Materiálů fakturovaných proti této objednávce.
-apps/erpnext/erpnext/controllers/selling_controller.py +155,Order Type must be one of {0},Typ objednávky musí být jedním z {0}
-DocType: Lead,Next Contact Date,Další Kontakt Datum
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +34,Opening Qty,Otevření POČET
-DocType: Holiday List,Holiday List Name,Jméno Holiday Seznam
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +163,Stock Options,Akciové opce
-DocType: Expense Claim,Expense Claim,Hrazení nákladů
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +164,Qty for {0},Množství pro {0}
-DocType: Leave Application,Leave Application,Leave Application
-apps/erpnext/erpnext/config/hr.py +77,Leave Allocation Tool,Nechte přidělení nástroj
-DocType: Leave Block List,Leave Block List Dates,Nechte Block List termíny
-DocType: Email Digest,Buying & Selling,Nákup a prodej
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +55,Trimming,Ořezávání
-DocType: Workstation,Net Hour Rate,Net Hour Rate
-DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Přistál Náklady doklad o koupi
-DocType: Packing Slip Item,Packing Slip Item,Balení Slip Item
-DocType: POS Setting,Cash/Bank Account,Hotovostní / Bankovní účet
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +58,Removed items with no change in quantity or value.,Odstraněné položky bez změny množství nebo hodnoty.
-DocType: Delivery Note,Delivery To,Doručení do
-DocType: Production Planning Tool,Get Sales Orders,Získat Prodejní objednávky
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +64,{0} can not be negative,{0} nemůže být negativní
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +198,"Row {0}: Party / Account does not match with \
+Purchase Returned,Nákup Vráceno,
+Bank A/C No.,"Č, bank. účtu"
+Scheduler Failed Events,Plánovač Nepodařilo Events,
+Project,Projekt,
+Reading 7,Čtení 7,
+Personal,Osobns,
+Expense Claim Type,Náklady na pojistná Type,
+Default settings for Shopping Cart,Výchozí nastavení Košík,
+"Journal Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Zápis do deníku {0} je spojen proti řádu {1}, zkontrolujte, zda by měl být tažen za pokrok v této faktuře."
+Biotechnology,Biotechnologie,
+Office Maintenance Expenses,Náklady Office údržby,
+Hemming,Hemming,
+Please enter Item first,"Prosím, nejdřív zadejte položku"
+Liability,Odpovědnost,
+Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankcionována Částka nemůže být větší než reklamace Částka v řádku {0}.
+Default Cost of Goods Sold Account,Výchozí Náklady na prodané zboží účtu,
+Price List not selected,Ceník není zvolen,
+Family Background,Rodinné poměry,
+Send Email,Odeslat email,
+No Permission,Nemáte oprávněnu,
+Default Bank Account,Výchozí Bankovní účet,
+"To filter based on Party, select Party Type first","Chcete-li filtrovat na základě Party, vyberte typ Party první"
+Nos,Nos,
+Bank Reconciliation Detail,Bank Odsouhlasení Detail,
+My Invoices,Moje Faktury,
+No employee found,Žádný zaměstnanec nalezeno,
+Stopped,Zastaveno,
+All Customer Contact,Vše Kontakt Zákazník,
+Upload stock balance via csv.,Nahrát nutnosti rovnováhy prostřednictvím CSV.
+Send Now,Odeslat nyns,
+Support Analytics,Podpora Analytics,
+Website Warehouse,Sklad pro web,
+"The day of the month on which auto invoice will be generated e.g. 05, 28 etc","Den měsíce, ve kterém auto faktura bude generován například 05, 28 atd"
+Score must be less than or equal to 5,Skóre musí být menší než nebo rovna 5,
+C-Form records,C-Form záznamy,
+Email Digest Settings,Nastavení e-mailu Digest,
+Support queries from customers.,Podpora dotazy ze strany zákazníků.
+Moving Average Rate,Klouzavý průměr,
+Select Items,Vyberte položky,
+{0} against Bill {1} dated {2},{0} proti účtu {1} ze dne {2}
+Reference Name,Název reference,
+Completion Status,Dokončení Status,
+"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","Chcete-li sledovat značku v těchto dokumentech dodacího listu Opportunity, materiál Request, bod, objednávky, nákup poukazu, nakupují stvrzenka, cenovou nabídku, prodejní faktury, Sales BOM, prodejní objednávky, pořadové číslo"
+Target Warehouse,Target Warehouse,
+Expected Delivery Date cannot be before Sales Order Date,"Očekávané datum dodání, nemůže být před Sales pořadí Datum"
+Import Attendance,Importovat Docházku,
+All Item Groups,Všechny skupiny položek,
+Activity Log,Aktivita Log,
+Net Profit / Loss,Čistý zisk / ztráta,
+Automatically compose message on submission of transactions.,Automaticky napsat vzkaz na předkládání transakcí.
+Item To Manufacture,Bod K výrobm,
+Permanent mold casting,Trvalé odlévání forem,
+Projected Qty,Předpokládané množstvm,
+Payment Due Date,Splatno dne,
+Newsletter Manager,Newsletter Manažer,
+Delivery Note Message,Delivery Note Message,
+Expenses,Výdaje,
+Purchase Receipt Trends,Doklad o koupi Trendy,
+Select template from which you want to get the Goals,"Vyberte šablonu, ze kterého chcete získat cílů"
+Research & Development,Výzkum a vývoj,
+Amount to Bill,Částka k Fakturaci,
+Registration Details,Registrace Podrobnosti,
+Staking,Sázet,
+Re-Order Qty,Re-Order Množstvj,
+Leave Block List Date,Nechte Block List Datum,
+Scheduled to send to {0},Plánované poslat na {0}
+Price or Discount,Cena nebo Sleva,
+Incentives,Pobídky,
+Performance appraisal.,Hodnocení výkonu.
+Project Value,Hodnota projektu,
+Make Maint. Visit,Proveďte údržba. Návštěva,
+Cannot carry forward {0},Nelze převést {0}
+"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Zůstatek na účtu již v Credit, není dovoleno stanovit ""Balance musí být"" jako ""debet"""
+Balance must be,Zůstatek musí být,
+Publish Pricing,Publikovat Ceník,
+New Purchase Receipts,Nové Nákup Příjmy,
+Expense Claim Rejected Message,Zpráva o zamítnutí úhrady výdajt,
+Nailing,Báječnt,
+Available Qty,Množství k dispozici,
+On Previous Row Total,Na předchozí řady Celkem,
+Working Days,Pracovní dny,
+Incoming Rate,Příchozí Rate,
+Gross Weight,Hrubá hmotnost,
+The name of your company for which you are setting up this system.,"Název vaší společnosti, pro kterou nastavení tohoto systému."
+Include holidays in Total no. of Working Days,Zahrnout dovolenou v celkovém. pracovních dnt,
+Hold,Držet,
+Date of Joining,Datum přistoupent,
+Update Series,Řada Aktualizace,
+Is Subcontracted,Subdodavatelům,
+Item Attribute Values,Položka Hodnoty atributt,
+View Subscribers,Zobrazit Odběratelt,
+Purchase Receipt,Příjemka,
+Received Items To Be Billed,"Přijaté položek, které mají být účtovány"
+Abrasive blasting,Abrazivní tryskán$1,
+Ms,Pan$1,
+Currency exchange rate master.,Devizový kurz master.
+Unable to find Time Slot in the next {0} days for Operation {1},Nelze najít časový úsek v příštích {0} dní k provozu {1}
+Plan material for sub-assemblies,Plán materiál pro podsestavy,
+BOM {0} must be active,BOM {0} musí být aktivny,
+Set Status as Available,Nastavit stav as k dispozici,
+Please select the document type first,Vyberte první typ dokumentu,
+Cancel Material Visits {0} before cancelling this Maintenance Visit,Zrušit Materiál Návštěvy {0} před zrušením tohoto návštěv údržby,
+Leave Encashment Amount,Nechte inkasa Částka,
+Serial No {0} does not belong to Item {1},Pořadové číslo {0} nepatří k bodu {1}
+Make new POS Setting,Proveďte nové nastavení POS,
+Required Qty,Požadované množstvS,
+Total Amount,Celková částka,
+Internet Publishing,Internet Publishing,
+Production Orders,Výrobní Objednávky,
+Balance Value,Zůstatek Hodnota,
+Sales Price List,Sales Ceník,
+Publish to sync items,Publikování synchronizovat položky,
+Range,Rozsah,
+Default Payable Accounts,Výchozí úplatu účty,
+Employee {0} is not active or does not exist,Zaměstnanec {0} není aktivní nebo neexistuje,
+Item Barcode,Položka Barcode,
+Item Variants {0} updated,Bod Varianty {0} aktualizováno,
+Reading 6,Čtení 6,
+Purchase Invoice Advance,Záloha přijaté faktury,
+Shop,Obchod,
+Sync Now,Sync teS,
+Row {0}: Credit entry can not be linked with a {1},Row {0}: Credit záznam nemůže být spojována s {1}
+Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,"Výchozí účet Bank / Cash budou automaticky aktualizovány v POS faktury, pokud je zvolen tento režim."
+Permanent Address Is,Trvalé bydliště je,
+Operation completed for how many finished goods?,Provoz dokončeno kolika hotových výrobků?
+The Brand,Brand,
+Allowance for over-{0} crossed for Item {1}.,Příspěvek na nadměrné {0} přešel k bodu {1}.
+Exit Interview Details,Exit Rozhovor Podrobnosti,
+Is Purchase Item,je Nákupní Položka,
+Purchase Invoice,Přijatá faktura,
+Voucher Detail No,Voucher Detail No,
+Total Outgoing Value,Celková hodnota Odchozi,
+Request for Information,Žádost o informace,
+Paid,Placeni,
+Total in words,Celkem slovy,
+Lead Time Date,Lead Time data,
+Row #{0}: Please specify Serial No for Item {1},Row # {0}: Zadejte Pořadové číslo k bodu {1}
+Shipments to customers.,Zásilky zákazníkům.
+Purchase Order Item,Položka vydané objednávky,
+Indirect Income,Nepřímé příjmy,
+Address Line 1,Adresní řádek 1,
+Variance,Odchylka,
+Company Name,Název společnosti,
+Total Message(s),Celkem zpráv (y)
+Select Item for Transfer,Vybrat položku pro převod,
+Select account head of the bank where cheque was deposited.,"Vyberte účet šéf banky, kde byla uložena kontrola."
+Allow user to edit Price List Rate in transactions,Povolit uživateli upravovat Ceník Cena při transakcích,
+Max Qty,Max Množstvh,
+Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Row {0}: Platba na prodejní / nákupní objednávce by měly být vždy označeny jako předem,
+Chemical,Chemickh,
+All items have already been transferred for this Production Order.,Všechny položky již byly převedeny na výrobu tohoto řádu.
+Select Payroll Year and Month,Vyberte Payroll rok a měsíc,
+"Go to the appropriate group (usually Application of Funds > Current Assets > Bank Accounts and create a new Account (by clicking on Add Child) of type ""Bank""",Přejděte na příslušné skupiny (obvykle využití finančních prostředků&gt; oběžných aktiv&gt; bankovních účtů a vytvořit nový účet (kliknutím na Přidat dítě) typu &quot;Bank&quot;
+Electricity Cost,Cena elektřiny,
+Don't send Employee Birthday Reminders,Neposílejte zaměstnance připomenutí narozenin,
+Unsubscribed,Odhlášen z odběru,
+Walk In,Vejít,
+Inspection Criteria,Inspekční Kritéria,
+Tree of finanial Cost Centers.,Strom finanial nákladových středisek.
+Upload your letter head and logo. (you can edit them later).,Nahrajte svůj dopis hlavu a logo. (Můžete je upravit později).
+White,Bíl$1,
+All Lead (Open),Všechny Lead (Otevřeny)
+Get Advances Paid,Získejte zaplacené zálohy,
+Attach Your Picture,Připojit svůj obrázek,
+Total Amount in Words,Celková částka slovy,
+Stop,Stop,
+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.,"Došlo k chybě. Jedním z důvodů by mohlo být pravděpodobné, že jste uložili formulář. Obraťte se prosím na support@erpnext.com Pokud problém přetrvává."
+% of materials billed against this Purchase Order.,% Materiálů fakturovaných proti této objednávce.
+Order Type must be one of {0},Typ objednávky musí být jedním z {0}
+Next Contact Date,Další Kontakt Datum,
+Opening Qty,Otevření POČET,
+Holiday List Name,Jméno Holiday Seznam,
+Stock Options,Akciové opce,
+Expense Claim,Hrazení nákladm,
+Qty for {0},Množství pro {0}
+Leave Application,Leave Application,
+Leave Allocation Tool,Nechte přidělení nástroj,
+Leave Block List Dates,Nechte Block List termíny,
+Buying & Selling,Nákup a prodej,
+Trimming,Ořezávánn,
+Net Hour Rate,Net Hour Rate,
+Landed Cost Purchase Receipt,Přistál Náklady doklad o koupi,
+Packing Slip Item,Balení Slip Item,
+Cash/Bank Account,Hotovostní / Bankovní účet,
+Removed items with no change in quantity or value.,Odstraněné položky bez změny množství nebo hodnoty.
+Delivery To,Doručení do,
+Get Sales Orders,Získat Prodejní objednávky,
+{0} can not be negative,{0} nemůže být negativno,
+"Row {0}: Party / Account does not match with \
 							Customer / Debit To in {1}","Row {0}: Party / Account neodpovídá \
  Customer / debetní v {1}"
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +102,Filing,Podání
-apps/erpnext/erpnext/templates/form_grid/item_grid.html +67,Discount,Sleva
-DocType: Features Setup,Purchase Discounts,Nákup Slevy
-DocType: Stock Entry,This will override Difference Account in Item,To přepíše Difference účet v položce
-DocType: Workstation,Wages,Mzdy
-DocType: Time Log,Will be updated only if Time Log is 'Billable',"Bude aktualizována pouze v případě, Time Log je &quot;Zúčtovatelná&quot;"
-DocType: Project,Internal,Interní
-DocType: Task,Urgent,Naléhavý
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +97,Please specify a valid Row ID for row {0} in table {1},Zadejte prosím platný řádek ID řádku tabulky {0} {1}
-apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +76,This Time Log conflicts with {0} for {1},To je v rozporu Time Log s {0} na {1}
-DocType: Sales BOM,"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 
+Filing,Podána,
+Discount,Sleva,
+Purchase Discounts,Nákup Slevy,
+This will override Difference Account in Item,To přepíše Difference účet v položce,
+Wages,Mzdy,
+Will be updated only if Time Log is 'Billable',"Bude aktualizována pouze v případě, Time Log je &quot;Zúčtovatelná&quot;"
+Internal,Intern$1,
+Urgent,Naléhav$1,
+Please specify a valid Row ID for row {0} in table {1},Zadejte prosím platný řádek ID řádku tabulky {0} {1}
+This Time Log conflicts with {0} for {1},To je v rozporu Time Log s {0} na {1}
+"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 
 
 The package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".
 
@@ -921,1105 +921,1105 @@
  Například: Pokud prodáváte notebooky a batohy odděleně a mají speciální cenu, pokud zákazník koupí oba, pak Laptop + Backpack bude nový Sales BOM položky.
 
  Poznámka: BOM = Bill of Materials"
-DocType: Item,Manufacturer,Výrobce
-DocType: Landed Cost Item,Purchase Receipt Item,Položka příjemky
-DocType: Sales Order,PO Date,PO Datum
-DocType: Serial No,Sales Returned,Sales Vrácené
-DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Vyhrazeno Warehouse v prodejní objednávky / hotových výrobků Warehouse
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +65,Selling Amount,Prodejní Částka
-apps/erpnext/erpnext/projects/doctype/project/project.js +37,Time Logs,Čas Záznamy
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +105,You are the Expense Approver for this record. Please Update the 'Status' and Save,"Jste Expense schvalujícím pro tento záznam. Prosím aktualizujte ""stavu"" a Uložit"
-DocType: Serial No,Creation Document No,Tvorba dokument č
-DocType: Issue,Issue,Problém
-apps/erpnext/erpnext/config/stock.py +136,"Attributes for Item Variants. e.g Size, Color etc.","Atributy pro položky varianty. například velikost, barva atd."
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +30,WIP Warehouse,WIP Warehouse
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +204,Serial No {0} is under maintenance contract upto {1},Pořadové číslo {0} je na základě smlouvy o údržbě aľ {1}
-DocType: BOM Operation,Operation,Operace
-DocType: Lead,Organization Name,Název organizace
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +385,POS Setting required to make POS Entry,"POS Nastavení požadováno, aby POS položky"
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item must be added using 'Get Items from Purchase Receipts' button,"Položka musí být přidány pomocí ""získat předměty z kupní příjmy"" tlačítkem"
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +126,Sales Expenses,Prodejní náklady
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +159,Standard Buying,Standardní Nakupování
-DocType: GL Entry,Against,Proti
-DocType: Item,Default Selling Cost Center,Výchozí Center Prodejní cena
-DocType: Sales Partner,Implementation Partner,Implementačního partnera
-DocType: Purchase Invoice,Contact Info,Kontaktní informace
-DocType: Packing Slip,Net Weight UOM,Hmotnost UOM
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +477,Make Purchase Receipt,Proveďte doklad o koupi
-DocType: Item,Default Supplier,Výchozí Dodavatel
-DocType: Shipping Rule Condition,Shipping Rule Condition,Přepravní Pravidlo Podmínka
-DocType: Features Setup,Miscelleneous,Miscelleneous
-DocType: Holiday List,Get Weekly Off Dates,Získejte týdenní Off termíny
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +30,End Date can not be less than Start Date,Datum ukončení nesmí být menší než data zahájení
-DocType: Sales Person,Select company name first.,Vyberte název společnosti jako první.
-DocType: Sales BOM Item,Sales BOM Item,Sales BOM Item
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +87,Dr,Dr
-apps/erpnext/erpnext/stock/doctype/item/item.py +317,"Item must be a purchase item, as it is present in one or many Active BOMs","Položka musí být nákup bod, protože je přítomna v jedné nebo mnoha Active kusovníky"
-apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Nabídka obdržená od Dodavatelů.
-DocType: Journal Entry Account,Against Purchase Invoice,Proti nákupní faktuře
-apps/erpnext/erpnext/controllers/selling_controller.py +21,To {0} | {1} {2},Chcete-li {0} | {1} {2}
-DocType: Time Log Batch,updated via Time Logs,aktualizovat přes čas Záznamy
-apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Průměrný věk
-apps/erpnext/erpnext/templates/includes/cart.js +59,Go ahead and add something to your cart.,Nyní můžete přidat položky do Vašeho košíku.
-DocType: Opportunity,Your sales person who will contact the customer in future,"Váš obchodní zástupce, který bude kontaktovat zákazníka v budoucnu"
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +537,List a few of your suppliers. They could be organizations or individuals.,Seznam několik svých dodavatelů. Ty by mohly být organizace nebo jednotlivci.
-DocType: Supplier,Default Currency,Výchozí měna
-DocType: Contact,Enter designation of this Contact,Zadejte označení této Kontakt
-DocType: Contact Us Settings,Address,Adresa
-DocType: Expense Claim,From Employee,Od Zaměstnance
-apps/erpnext/erpnext/accounts/utils.py +39,{0} {1} not in any Fiscal Year. For more details check {2}.,{0} {1} v žádném fiskálním roce. Pro více informací klikněte {2}.
-apps/erpnext/erpnext/controllers/accounts_controller.py +269,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,"Upozornění: Systém nebude kontrolovat nadfakturace, protože částka za položku na {1} je nula {0}"
-DocType: Journal Entry,Make Difference Entry,Učinit vstup Rozdíl
-DocType: Upload Attendance,Attendance From Date,Účast Datum od
-DocType: Appraisal Template Goal,Key Performance Area,Key Performance Area
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +53,Transportation,Doprava
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +393,{0} {1} must be submitted,{0} {1} musí být odeslaný
-DocType: SMS Center,Total Characters,Celkový počet znaků
-apps/erpnext/erpnext/controllers/buying_controller.py +140,Please select BOM in BOM field for Item {0},Vyberte kusovník Bom oblasti k bodu {0}
-DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Form Faktura Detail
-DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Platba Odsouhlasení faktury
-apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32,Contribution %,Příspěvek%
-DocType: Item,website page link,webové stránky odkaz na stránku
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +191,Let's prepare the system for first use.,Pojďme připravit systém pro první použití.
-DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Registrace firmy čísla pro váš odkaz. Daňové čísla atd
-DocType: Sales Partner,Distributor,Distributor
-DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Nákupní košík Shipping Rule
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +195,Production Order {0} must be cancelled before cancelling this Sales Order,Výrobní zakázka {0} musí být zrušena před zrušením této prodejní objednávky
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +53,Budget cannot be set for Group Cost Centers,Rozpočet není možno nastavit pro středisek Skupina nákladová
-,Ordered Items To Be Billed,Objednané zboží fakturovaných
-apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +21,Select Time Logs and Submit to create a new Sales Invoice.,Vyberte Time protokolů a předložit k vytvoření nové prodejní faktury.
-DocType: Global Defaults,Global Defaults,Globální Výchozí
-DocType: Salary Slip,Deductions,Odpočty
-DocType: Purchase Invoice,Start date of current invoice's period,Datum období současného faktury je Začátek
-apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +23,This Time Log Batch has been billed.,To Batch Time Log bylo účtováno.
-apps/erpnext/erpnext/crm/doctype/lead/lead.js +32,Create Opportunity,Vytvořit příležitost
-DocType: Salary Slip,Leave Without Pay,Nechat bez nároku na mzdu
-DocType: Supplier,Communications,Komunikace
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +275,Capacity Planning Error,Plánování kapacit Chyba
-DocType: Lead,Consultant,Konzultant
-DocType: Salary Slip,Earnings,Výdělek
-DocType: Sales Invoice Advance,Sales Invoice Advance,Prodejní faktury Advance
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +404,Nothing to request,Nic požadovat
-apps/erpnext/erpnext/projects/doctype/task/task.py +37,'Actual Start Date' can not be greater than 'Actual End Date',"""Skutečné datum zahájení"" nemůže být větší než ""Aktuální datum ukončení"""
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +70,Management,Řízení
-apps/erpnext/erpnext/config/projects.py +33,Types of activities for Time Sheets,Typy činností pro Time listy
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +13,Investment casting,Investiční lití
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +45,Either debit or credit amount is required for {0},Buď debetní nebo kreditní částka je vyžadována pro {0}
-DocType: Item Attribute Value,"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","To bude připojen na položku zákoníku varianty. Například, pokud vaše zkratka je ""SM"", a položka je kód ""T-SHIRT"", položka kód varianty bude ""T-SHIRT-SM"""
-DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,"Čistá Pay (slovy) budou viditelné, jakmile uložíte výplatní pásce."
-apps/frappe/frappe/core/doctype/user/user_list.js +12,Active,Aktivní
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +149,Blue,Modrý
-apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +120,Further nodes can be only created under 'Group' type nodes,"Další uzly mohou být pouze vytvořena v uzlech typu ""skupiny"""
-DocType: Item,UOMs,UOMs
-apps/erpnext/erpnext/stock/utils.py +167,{0} valid serial nos for Item {1},{0} platí pořadová čísla pro položky {1}
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +58,Item Code cannot be changed for Serial No.,Kód položky nemůže být změněn pro Serial No.
-DocType: Purchase Order Item,UOM Conversion Factor,UOM Conversion Factor
-DocType: Stock Settings,Default Item Group,Výchozí bod Group
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +155,Laminated object manufacturing,Vrstvené objektu výrobní
-apps/erpnext/erpnext/config/buying.py +13,Supplier database.,Databáze dodavatelů.
-DocType: Account,Balance Sheet,Rozvaha
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +596,Cost Center For Item with Item Code ',"Nákladové středisko u položky s Kód položky """
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +44,Stretch forming,Stretch tváření
-DocType: Opportunity,Your sales person will get a reminder on this date to contact the customer,"Váš obchodní zástupce dostane upomínku na tento den, aby kontaktoval zákazníka"
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +203,"Further accounts can be made under Groups, but entries can be made against non-Groups","Další účty mohou být vyrobeny v rámci skupiny, ale údaje lze proti non-skupin"
-apps/erpnext/erpnext/config/hr.py +125,Tax and other salary deductions.,Daňové a jiné platové srážky.
-DocType: Lead,Lead,Olovo
-DocType: Email Digest,Payables,Závazky
-DocType: Account,Warehouse,Sklad
-,Purchase Order Items To Be Billed,Položky vydané objednávky k fakturaci
-DocType: Purchase Invoice Item,Net Rate,Čistá míra
-DocType: Backup Manager,Database Folder ID,číslo databázového adresára
-DocType: Purchase Invoice Item,Purchase Invoice Item,Položka přijaté faktury
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +50,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Sériové Ledger Přihlášky a GL položky jsou zveřejňována pro vybrané Nákupní Příjmy
-DocType: Holiday,Holiday,Dovolená
-DocType: Event,Saturday,Sobota
-DocType: Leave Control Panel,Leave blank if considered for all branches,"Ponechte prázdné, pokud se to považuje za všechny obory"
-,Daily Time Log Summary,Denní doba prihlásenia - súhrn
-DocType: DocField,Label,Popisek
-DocType: Payment Reconciliation,Unreconciled Payment Details,Smířit platbě
-DocType: Global Defaults,Current Fiscal Year,Aktuální fiskální rok
-DocType: Global Defaults,Disable Rounded Total,Zakázat Zaoblený Celkem
-DocType: Lead,Call,Volání
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356,'Entries' cannot be empty,"""Položky"" nemůžou být prázdné"
-apps/erpnext/erpnext/utilities/transaction_base.py +72,Duplicate row {0} with same {1},Duplicitní řádek {0} se stejným {1}
-,Trial Balance,Trial Balance
-sites/assets/js/erpnext.min.js +2,"Grid ""","Grid """
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +145,Please select prefix first,"Prosím, vyberte první prefix"
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +133,Research,Výzkum
-DocType: Maintenance Visit Purpose,Work Done,Odvedenou práci
-DocType: Employee,User ID,User ID
-DocType: Communication,Sent,Odesláno
-apps/erpnext/erpnext/accounts/doctype/account/account.js +57,View Ledger,View Ledger
-DocType: Cost Center,Lft,LFT
-apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Nejstarší
-apps/erpnext/erpnext/stock/doctype/item/item.py +387,"An Item Group exists with same name, please change the item name or rename the item group","Položka Group existuje se stejným názvem, prosím, změnit název položky nebo přejmenovat skupinu položek"
-DocType: Sales Order,Delivery Status,Delivery Status
-DocType: Production Order,Manufacture against Sales Order,Výroba na odběratele
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +443,Rest Of The World,Zbytek světa
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +72,The Item {0} cannot have Batch,Položka {0} nemůže mít dávku
-,Budget Variance Report,Rozpočet Odchylka Report
-DocType: Salary Slip,Gross Pay,Hrubé mzdy
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +186,Dividends Paid,Dividendy placené
-DocType: Stock Reconciliation,Difference Amount,Rozdíl Částka
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +192,Retained Earnings,Nerozdělený zisk
-DocType: Purchase Order,Required raw materials issued to the supplier for producing a sub - contracted item.,Potřebné suroviny vydaných dodavateli pro výrobu sub - smluvně položka.
-DocType: BOM Item,Item Description,Položka Popis
-DocType: Payment Tool,Payment Mode,Způsob platby
-DocType: Purchase Invoice,Is Recurring,Je Opakující
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +153,Direct metal laser sintering,Přímý plechu laserem spékání
-DocType: Purchase Order,Supplied Items,Dodávané položky
-DocType: Production Order,Qty To Manufacture,Množství K výrobě
-DocType: Buying Settings,Maintain same rate throughout purchase cycle,Udržovat stejnou sazbu po celou kupní cyklu
-DocType: Opportunity Item,Opportunity Item,Položka Příležitosti
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61,Temporary Opening,Dočasné Otevření
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +40,Cryorolling,Cryorolling
-,Employee Leave Balance,Zaměstnanec Leave Balance
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +101,Balance for Account {0} must always be {1},Zůstatek na účtě {0} musí být vždy {1}
-DocType: Sales Invoice,More Info,Více informací
-DocType: Address,Address Type,Typ adresy
-DocType: Purchase Receipt,Rejected Warehouse,Zamítnuto Warehouse
-DocType: GL Entry,Against Voucher,Proti poukazu
-DocType: Item,Default Buying Cost Center,Výchozí Center Nákup Cost
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +42,Item {0} must be Sales Item,Položka {0} musí být Sales Item
-,Accounts Payable Summary,Splatné účty Shrnutí
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +159,Not authorized to edit frozen Account {0},Není povoleno upravovat zmrazený účet {0}
-DocType: Journal Entry,Get Outstanding Invoices,Získat neuhrazených faktur
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +55,Sales Order {0} is not valid,Prodejní objednávky {0} není platný
-DocType: Email Digest,New Stock Entries,Nových akcií Příspěvky
-apps/erpnext/erpnext/setup/doctype/company/company.py +161,"Sorry, companies cannot be merged","Je nám líto, společnosti nemohou být sloučeny"
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +140,Small,Malý
-DocType: Employee,Employee Number,Počet zaměstnanců
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +65,Case No(s) already in use. Try from Case No {0},Případ číslo (čísla) již v provozu. Zkuste se věc č {0}
-DocType: Material Request,% Completed,% Dokončeno
-,Invoiced Amount (Exculsive Tax),Fakturovaná částka (bez daně)
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +59,Account head {0} created,Hlava účtu {0} vytvořil
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +148,Green,Zelená
-DocType: Sales Order Item,Discount(%),Sleva (%)
-apps/erpnext/erpnext/selling/report/territory_target_variance_item_group_wise/territory_target_variance_item_group_wise.py +57,Total Achieved,Celkem Dosažená
-DocType: Employee,Place of Issue,Místo vydání
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +54,Contract,Smlouva
-DocType: Report,Disabled,Vypnuto
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +523,UOM coversion factor required for UOM: {0} in Item: {1},UOM coversion faktor potřebný k nerozpuštěných: {0} v bodě: {1}
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +83,Indirect Expenses,Nepřímé náklady
-apps/erpnext/erpnext/controllers/selling_controller.py +171,Row {0}: Qty is mandatory,Row {0}: Množství je povinný
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +7,Agriculture,Zemědělství
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +559,Your Products or Services,Vaše Produkty nebo Služby
-DocType: Mode of Payment,Mode of Payment,Způsob platby
-apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +31,This is a root item group and cannot be edited.,Jedná se o skupinu kořen položky a nelze upravovat.
-DocType: Purchase Invoice Item,Purchase Order,Vydaná objednávka
-DocType: Warehouse,Warehouse Contact Info,Sklad Kontaktní informace
-sites/assets/js/form.min.js +180,Name is required,Jméno je vyžadováno
-DocType: Purchase Invoice,Recurring Type,Opakující se Typ
-DocType: Address,City/Town,Město / Město
-DocType: Serial No,Serial No Details,Serial No Podrobnosti
-DocType: Purchase Invoice Item,Item Tax Rate,Sazba daně položky
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +132,"For {0}, only credit accounts can be linked against another debit entry","Pro {0}, tak úvěrové účty mohou být propojeny na jinou položku debetní"
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +428,Delivery Note {0} is not submitted,Delivery Note {0} není předložena
-apps/erpnext/erpnext/stock/get_item_details.py +137,Item {0} must be a Sub-contracted Item,Položka {0} musí být Subdodavatelské Item
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +41,Capital Equipments,Kapitálové Vybavení
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +31,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Ceny Pravidlo je nejprve vybrána na základě ""Použít na"" oblasti, které mohou být položky, položky skupiny nebo značky."
-DocType: Hub Settings,Seller Website,Prodejce Website
-apps/erpnext/erpnext/controllers/selling_controller.py +148,Total allocated percentage for sales team should be 100,Celkové přidělené procento prodejní tým by měl být 100
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +103,Production Order status is {0},Stav výrobní zakázka je {0}
-DocType: Appraisal Goal,Goal,Cíl
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +572,For Supplier,Pro Dodavatele
-DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Nastavení typu účtu pomáhá při výběru tohoto účtu v transakcích.
-DocType: Purchase Invoice,Grand Total (Company Currency),Celkový součet (Měna společnosti)
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,Celkem Odchozí
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +42,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Tam může být pouze jeden Shipping Rule Podmínka s 0 nebo prázdnou hodnotu pro ""na hodnotu"""
-DocType: DocType,Transaction,Transakce
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Poznámka: Tento Nákladové středisko je Group. Nelze vytvořit účetní zápisy proti skupinám.
-apps/erpnext/erpnext/config/projects.py +43,Tools,Nástroje
-DocType: Sales Taxes and Charges Template,Valid For Territories,Platí pro území
-DocType: Item,Website Item Groups,Webové stránky skupiny položek
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +190,Production order number is mandatory for stock entry purpose manufacture,Výrobní číslo objednávky je povinná pro legální vstup účelem výroby
-DocType: Purchase Invoice,Total (Company Currency),Total (Company měny)
-DocType: Applicable Territory,Applicable Territory,Použitelné Oblasti
-apps/erpnext/erpnext/stock/utils.py +162,Serial number {0} entered more than once,Výrobní číslo {0} přihlášeno více než jednou
-DocType: Journal Entry,Journal Entry,Zápis do deníku
-DocType: Workstation,Workstation Name,Meno pracovnej stanice
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +19,Email Digest:,E-mail Digest:
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +429,BOM {0} does not belong to Item {1},BOM {0} nepatří k bodu {1}
-DocType: Sales Partner,Target Distribution,Target Distribution
-sites/assets/js/desk.min.js +536,Comments,Komentáře
-DocType: Salary Slip,Bank Account No.,Bankovní účet č.
-DocType: Naming Series,This is the number of the last created transaction with this prefix,To je číslo poslední vytvořené transakci s tímto prefixem
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +167,Valuation Rate required for Item {0},Ocenění Rate potřebný k bodu {0}
-DocType: Quality Inspection Reading,Reading 8,Čtení 8
-DocType: Sales Partner,Agent,Agent
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +74,"Total {0} for all items is zero, may you should change 'Distribute Charges Based On'","Celkem {0} pro všechny položky je nula, můžete měli změnit &quot;Distribuovat poplatků na základě&quot;"
-DocType: Purchase Invoice,Taxes and Charges Calculation,Daně a poplatky výpočet
-DocType: BOM Operation,Workstation,pracovna stanica
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +107,Hardware,Technické vybavení
-DocType: Attendance,HR Manager,HR Manager
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +47,Privilege Leave,Privilege Leave
-DocType: Purchase Invoice,Supplier Invoice Date,Dodavatelské faktury Datum
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +169,You need to enable Shopping Cart,Musíte povolit Nákupní košík
-sites/assets/js/form.min.js +197,No Data,No Data
-DocType: Appraisal Template Goal,Appraisal Template Goal,Posouzení Template Goal
-DocType: Salary Slip,Earning,Získávání
-DocType: Purchase Taxes and Charges,Add or Deduct,Přidat nebo Odečíst
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +75,Overlapping conditions found between:,Překrývající podmínky nalezeno mezi:
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +134,Against Journal Entry {0} is already adjusted against some other voucher,Proti věstníku Entry {0} je již nastavena proti jiným poukaz
-DocType: Backup Manager,Files Folder ID,ID složeky souborů
-apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +58,Total Order Value,Celková hodnota objednávky
-apps/erpnext/erpnext/stock/doctype/item/item.py +196,Item Variants {0} deleted,Bod Varianty {0} vypouští
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +38,Food,Jídlo
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +51,Ageing Range 3,Stárnutí Rozsah 3
-apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +127,You can make a time log only against a submitted production order,Můžete udělat časový záznam pouze proti předložené výrobní objednávce
-DocType: Maintenance Schedule Item,No of Visits,Počet návštěv
-DocType: Cost Center,old_parent,old_parent
-apps/erpnext/erpnext/config/support.py +33,"Newsletters to contacts, leads.","Zpravodaje ke kontaktům, vede."
-apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Součet bodů za všech cílů by mělo být 100. Je {0}
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +368,Operations cannot be left blank.,Operace nemůže být prázdné.
-,Delivered Items To Be Billed,Dodávaných výrobků fakturovaných
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +61,Warehouse cannot be changed for Serial No.,Warehouse nemůže být změněn pro Serial No.
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +99,Status updated to {0},Status aktualizován na {0}
-DocType: DocField,Description,Popis
-DocType: Authorization Rule,Average Discount,Průměrná sleva
-DocType: Backup Manager,Backup Manager,Správce zálohování
-DocType: Letter Head,Is Default,Je Výchozí
-DocType: Address,Utilities,Utilities
-DocType: Purchase Invoice Item,Accounting,Účetnictví
-DocType: Features Setup,Features Setup,Nastavení Funkcí
-apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,View Offer Letter,View Nabídka Dopis
-DocType: Sales BOM,Sales BOM,Sales BOM
-DocType: Communication,Communication,Komunikace
-DocType: Item,Is Service Item,Je Service Item
-DocType: Activity Cost,Projects,Projekty
-apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +30,Please select Fiscal Year,"Prosím, vyberte Fiskální rok"
-apps/erpnext/erpnext/controllers/buying_controller.py +23,From {0} | {1} {2},Od {0} | {1} {2}
-DocType: BOM Operation,Operation Description,Operace Popis
-DocType: Item,Will also apply to variants,Bude se vztahovat i na varianty
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +30,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,"Nelze měnit Fiskální rok Datum zahájení a fiskální rok datum ukončení, jakmile fiskální rok se uloží."
-DocType: Quotation,Shopping Cart,Nákupní vozík
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Avg Daily Odchozí
-DocType: Pricing Rule,Campaign,Kampaň
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +29,Approval Status must be 'Approved' or 'Rejected',"Stav schválení musí být ""schváleno"" nebo ""Zamítnuto"""
-DocType: Sales Invoice,Sales BOM Help,Sales BOM Help
-DocType: Purchase Invoice,Contact Person,Kontaktní osoba
-apps/erpnext/erpnext/projects/doctype/task/task.py +34,'Expected Start Date' can not be greater than 'Expected End Date',"""Očekávaný Datum Začátku"" nemůže být větší než ""Očekávanou Datum Konce"""
-DocType: Holiday List,Holidays,Prázdniny
-DocType: Sales Order Item,Planned Quantity,Plánované Množství
-DocType: Purchase Invoice Item,Item Tax Amount,Částka Daně Položky
-DocType: Supplier Quotation,Get Terms and Conditions,Získejte Smluvní podmínky
-DocType: Leave Control Panel,Leave blank if considered for all designations,"Ponechte prázdné, pokud se to považuje za všechny označení"
-apps/erpnext/erpnext/controllers/accounts_controller.py +391,Charge of type 'Actual' in row {0} cannot be included in Item Rate,"Obvinění z typu ""Aktuální"" v řádku {0} nemůže být zařazena do položky Rate"
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +165,Max: {0},Max: {0}
-apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +16,From Datetime,Od datetime
-DocType: Email Digest,For Company,Pro Společnost
-apps/erpnext/erpnext/config/support.py +38,Communication log.,Komunikační protokol.
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +66,Buying Amount,Nákup Částka
-DocType: Sales Invoice,Shipping Address Name,Přepravní Adresa Název
-apps/erpnext/erpnext/accounts/doctype/account/account.js +50,Chart of Accounts,Diagram účtů
-DocType: Material Request,Terms and Conditions Content,Podmínky Content
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +506,cannot be greater than 100,nemůže být větší než 100
-DocType: Purchase Receipt Item,Discount  %,Sleva%
-apps/erpnext/erpnext/stock/doctype/item/item.py +473,Item {0} is not a stock Item,Položka {0} není skladem
-DocType: Maintenance Visit,Unscheduled,Neplánovaná
-DocType: Employee,Owned,Vlastník
-DocType: Pricing Rule,"Higher the number, higher the priority","Vyšší číslo, vyšší priorita"
-,Purchase Invoice Trends,Trendy přijatách faktur
-DocType: Employee,Better Prospects,Lepší vyhlídky
-DocType: Appraisal,Goals,Cíle
-DocType: Warranty Claim,Warranty / AMC Status,Záruka / AMC Status
-,Accounts Browser,Účty Browser
-DocType: GL Entry,GL Entry,Vstup GL
-DocType: HR Settings,Employee Settings,Nastavení zaměstnanců
-,Batch-Wise Balance History,Batch-Wise Balance History
-DocType: Email Digest,To Do List,Do List
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +58,Apprentice,Učeň
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +94,Negative Quantity is not allowed,Negativní množství není dovoleno
-DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
+Manufacturer,Výrobce,
+Purchase Receipt Item,Položka příjemky,
+PO Date,PO Datum,
+Sales Returned,Sales Vrácene,
+Reserved Warehouse in Sales Order / Finished Goods Warehouse,Vyhrazeno Warehouse v prodejní objednávky / hotových výrobků Warehouse,
+Selling Amount,Prodejní Částka,
+Time Logs,Čas Záznamy,
+You are the Expense Approver for this record. Please Update the 'Status' and Save,"Jste Expense schvalujícím pro tento záznam. Prosím aktualizujte ""stavu"" a Uložit"
+Creation Document No,Tvorba dokument m,
+Issue,Problém,
+"Attributes for Item Variants. e.g Size, Color etc.","Atributy pro položky varianty. například velikost, barva atd."
+WIP Warehouse,WIP Warehouse,
+Serial No {0} is under maintenance contract upto {1},Pořadové číslo {0} je na základě smlouvy o údržbě aľ {1}
+Operation,Operace,
+Organization Name,Název organizace,
+POS Setting required to make POS Entry,"POS Nastavení požadováno, aby POS položky"
+Item must be added using 'Get Items from Purchase Receipts' button,"Položka musí být přidány pomocí ""získat předměty z kupní příjmy"" tlačítkem"
+Sales Expenses,Prodejní náklady,
+Standard Buying,Standardní Nakupovány,
+Against,Proti,
+Default Selling Cost Center,Výchozí Center Prodejní cena,
+Implementation Partner,Implementačního partnera,
+Contact Info,Kontaktní informace,
+Net Weight UOM,Hmotnost UOM,
+Make Purchase Receipt,Proveďte doklad o koupi,
+Default Supplier,Výchozí Dodavatel,
+Shipping Rule Condition,Přepravní Pravidlo Podmínka,
+Miscelleneous,Miscelleneous,
+Get Weekly Off Dates,Získejte týdenní Off termíny,
+End Date can not be less than Start Date,Datum ukončení nesmí být menší než data zahájeny,
+Select company name first.,Vyberte název společnosti jako první.
+Sales BOM Item,Sales BOM Item,
+Dr,Dr,
+"Item must be a purchase item, as it is present in one or many Active BOMs","Položka musí být nákup bod, protože je přítomna v jedné nebo mnoha Active kusovníky"
+Quotations received from Suppliers.,Nabídka obdržená od Dodavatelů.
+Against Purchase Invoice,Proti nákupní faktuře,
+To {0} | {1} {2},Chcete-li {0} | {1} {2}
+updated via Time Logs,aktualizovat přes čas Záznamy,
+Average Age,Průměrný věk,
+Go ahead and add something to your cart.,Nyní můžete přidat položky do Vašeho košíku.
+Your sales person who will contact the customer in future,"Váš obchodní zástupce, který bude kontaktovat zákazníka v budoucnu"
+List a few of your suppliers. They could be organizations or individuals.,Seznam několik svých dodavatelů. Ty by mohly být organizace nebo jednotlivci.
+Default Currency,Výchozí měna,
+Enter designation of this Contact,Zadejte označení této Kontakt,
+Address,Adresa,
+From Employee,Od Zaměstnance,
+{0} {1} not in any Fiscal Year. For more details check {2}.,{0} {1} v žádném fiskálním roce. Pro více informací klikněte {2}.
+Warning: System will not check overbilling since amount for Item {0} in {1} is zero,"Upozornění: Systém nebude kontrolovat nadfakturace, protože částka za položku na {1} je nula {0}"
+Make Difference Entry,Učinit vstup Rozdíl,
+Attendance From Date,Účast Datum od,
+Key Performance Area,Key Performance Area,
+Transportation,Doprava,
+{0} {1} must be submitted,{0} {1} musí být odeslanl,
+Total Characters,Celkový počet znakl,
+Please select BOM in BOM field for Item {0},Vyberte kusovník Bom oblasti k bodu {0}
+C-Form Invoice Detail,C-Form Faktura Detail,
+Payment Reconciliation Invoice,Platba Odsouhlasení faktury,
+Contribution %,Příspěvek%
+website page link,webové stránky odkaz na stránku,
+Let's prepare the system for first use.,Pojďme připravit systém pro první použití.
+Company registration numbers for your reference. Tax numbers etc.,Registrace firmy čísla pro váš odkaz. Daňové čísla atd,
+Distributor,Distributor,
+Shopping Cart Shipping Rule,Nákupní košík Shipping Rule,
+Production Order {0} must be cancelled before cancelling this Sales Order,Výrobní zakázka {0} musí být zrušena před zrušením této prodejní objednávky,
+Budget cannot be set for Group Cost Centers,Rozpočet není možno nastavit pro středisek Skupina nákladovd,
+Ordered Items To Be Billed,Objednané zboží fakturovaných,
+Select Time Logs and Submit to create a new Sales Invoice.,Vyberte Time protokolů a předložit k vytvoření nové prodejní faktury.
+Global Defaults,Globální Výchozy,
+Deductions,Odpočty,
+Start date of current invoice's period,Datum období současného faktury je Začátek,
+This Time Log Batch has been billed.,To Batch Time Log bylo účtováno.
+Create Opportunity,Vytvořit příležitost,
+Leave Without Pay,Nechat bez nároku na mzdu,
+Communications,Komunikace,
+Capacity Planning Error,Plánování kapacit Chyba,
+Consultant,Konzultant,
+Earnings,Výdělek,
+Sales Invoice Advance,Prodejní faktury Advance,
+Nothing to request,Nic požadovat,
+'Actual Start Date' can not be greater than 'Actual End Date',"""Skutečné datum zahájení"" nemůže být větší než ""Aktuální datum ukončení"""
+Management,Řízeny,
+Types of activities for Time Sheets,Typy činností pro Time listy,
+Investment casting,Investiční lity,
+Either debit or credit amount is required for {0},Buď debetní nebo kreditní částka je vyžadována pro {0}
+"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","To bude připojen na položku zákoníku varianty. Například, pokud vaše zkratka je ""SM"", a položka je kód ""T-SHIRT"", položka kód varianty bude ""T-SHIRT-SM"""
+Net Pay (in words) will be visible once you save the Salary Slip.,"Čistá Pay (slovy) budou viditelné, jakmile uložíte výplatní pásce."
+Active,Aktivn$1,
+Blue,Modr$1,
+Further nodes can be only created under 'Group' type nodes,"Další uzly mohou být pouze vytvořena v uzlech typu ""skupiny"""
+UOMs,UOMs,
+{0} valid serial nos for Item {1},{0} platí pořadová čísla pro položky {1}
+Item Code cannot be changed for Serial No.,Kód položky nemůže být změněn pro Serial No.
+UOM Conversion Factor,UOM Conversion Factor,
+Default Item Group,Výchozí bod Group,
+Laminated object manufacturing,Vrstvené objektu výrobnr,
+Supplier database.,Databáze dodavatelů.
+Balance Sheet,Rozvaha,
+Cost Center For Item with Item Code ',"Nákladové středisko u položky s Kód položky """
+Stretch forming,Stretch tvářen$1,
+Your sales person will get a reminder on this date to contact the customer,"Váš obchodní zástupce dostane upomínku na tento den, aby kontaktoval zákazníka"
+"Further accounts can be made under Groups, but entries can be made against non-Groups","Další účty mohou být vyrobeny v rámci skupiny, ale údaje lze proti non-skupin"
+Tax and other salary deductions.,Daňové a jiné platové srážky.
+Lead,Olovo,
+Payables,Závazky,
+Warehouse,Sklad,
+Purchase Order Items To Be Billed,Položky vydané objednávky k fakturaci,
+Net Rate,Čistá míra,
+Database Folder ID,číslo databázového adresára,
+Purchase Invoice Item,Položka přijaté faktury,
+Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Sériové Ledger Přihlášky a GL položky jsou zveřejňována pro vybrané Nákupní Příjmy,
+Holiday,Dovoleno,
+Saturday,Sobota,
+Leave blank if considered for all branches,"Ponechte prázdné, pokud se to považuje za všechny obory"
+Daily Time Log Summary,Denní doba prihlásenia - súhrn,
+Label,Popisek,
+Unreconciled Payment Details,Smířit platbn,
+Current Fiscal Year,Aktuální fiskální rok,
+Disable Rounded Total,Zakázat Zaoblený Celkem,
+Call,Volánn,
+'Entries' cannot be empty,"""Položky"" nemůžou být prázdné"
+Duplicate row {0} with same {1},Duplicitní řádek {0} se stejným {1}
+Trial Balance,Trial Balance,
+"Grid ""","Grid """
+Please select prefix first,"Prosím, vyberte první prefix"
+Research,Výzkum,
+Work Done,Odvedenou práci,
+User ID,User ID,
+Sent,Odesláno,
+View Ledger,View Ledger,
+Lft,LFT,
+Earliest,Nejstaršm,
+"An Item Group exists with same name, please change the item name or rename the item group","Položka Group existuje se stejným názvem, prosím, změnit název položky nebo přejmenovat skupinu položek"
+Delivery Status,Delivery Status,
+Manufacture against Sales Order,Výroba na odběratele,
+Rest Of The World,Zbytek světa,
+The Item {0} cannot have Batch,Položka {0} nemůže mít dávku,
+Budget Variance Report,Rozpočet Odchylka Report,
+Gross Pay,Hrubé mzdy,
+Dividends Paid,Dividendy placens,
+Difference Amount,Rozdíl Částka,
+Retained Earnings,Nerozdělený zisk,
+Required raw materials issued to the supplier for producing a sub - contracted item.,Potřebné suroviny vydaných dodavateli pro výrobu sub - smluvně položka.
+Item Description,Položka Popis,
+Payment Mode,Způsob platby,
+Is Recurring,Je Opakujícs,
+Direct metal laser sintering,Přímý plechu laserem spékáns,
+Supplied Items,Dodávané položky,
+Qty To Manufacture,Množství K výrobs,
+Maintain same rate throughout purchase cycle,Udržovat stejnou sazbu po celou kupní cyklu,
+Opportunity Item,Položka Příležitosti,
+Temporary Opening,Dočasné Otevřens,
+Cryorolling,Cryorolling,
+Employee Leave Balance,Zaměstnanec Leave Balance,
+Balance for Account {0} must always be {1},Zůstatek na účtě {0} musí být vždy {1}
+More Info,Více informacy,
+Address Type,Typ adresy,
+Rejected Warehouse,Zamítnuto Warehouse,
+Against Voucher,Proti poukazu,
+Default Buying Cost Center,Výchozí Center Nákup Cost,
+Item {0} must be Sales Item,Položka {0} musí být Sales Item,
+Accounts Payable Summary,Splatné účty Shrnuty,
+Not authorized to edit frozen Account {0},Není povoleno upravovat zmrazený účet {0}
+Get Outstanding Invoices,Získat neuhrazených faktur,
+Sales Order {0} is not valid,Prodejní objednávky {0} není platnr,
+New Stock Entries,Nových akcií Příspěvky,
+"Sorry, companies cannot be merged","Je nám líto, společnosti nemohou být sloučeny"
+Small,Mal$1,
+Employee Number,Počet zaměstnanc$1,
+Case No(s) already in use. Try from Case No {0},Případ číslo (čísla) již v provozu. Zkuste se věc č {0}
+% Completed,% Dokončeno,
+Invoiced Amount (Exculsive Tax),Fakturovaná částka (bez daně)
+Account head {0} created,Hlava účtu {0} vytvořil,
+Green,Zelenl,
+Discount(%),Sleva (%)
+Total Achieved,Celkem Dosažena,
+Place of Issue,Místo vydána,
+Contract,Smlouva,
+Disabled,Vypnuto,
+UOM coversion factor required for UOM: {0} in Item: {1},UOM coversion faktor potřebný k nerozpuštěných: {0} v bodě: {1}
+Indirect Expenses,Nepřímé náklady,
+Row {0}: Qty is mandatory,Row {0}: Množství je povinny,
+Agriculture,Zemědělstvy,
+Your Products or Services,Vaše Produkty nebo Služby,
+Mode of Payment,Způsob platby,
+This is a root item group and cannot be edited.,Jedná se o skupinu kořen položky a nelze upravovat.
+Purchase Order,Vydaná objednávka,
+Warehouse Contact Info,Sklad Kontaktní informace,
+Name is required,Jméno je vyžadováno,
+Recurring Type,Opakující se Typ,
+City/Town,Město / Město,
+Serial No Details,Serial No Podrobnosti,
+Item Tax Rate,Sazba daně položky,
+"For {0}, only credit accounts can be linked against another debit entry","Pro {0}, tak úvěrové účty mohou být propojeny na jinou položku debetní"
+Delivery Note {0} is not submitted,Delivery Note {0} není předložena,
+Item {0} must be a Sub-contracted Item,Položka {0} musí být Subdodavatelské Item,
+Capital Equipments,Kapitálové Vybavena,
+"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Ceny Pravidlo je nejprve vybrána na základě ""Použít na"" oblasti, které mohou být položky, položky skupiny nebo značky."
+Seller Website,Prodejce Website,
+Total allocated percentage for sales team should be 100,Celkové přidělené procento prodejní tým by měl být 100,
+Production Order status is {0},Stav výrobní zakázka je {0}
+Goal,Cíl,
+For Supplier,Pro Dodavatele,
+Setting Account Type helps in selecting this Account in transactions.,Nastavení typu účtu pomáhá při výběru tohoto účtu v transakcích.
+Grand Total (Company Currency),Celkový součet (Měna společnosti)
+Total Outgoing,Celkem Odchoz$1,
+"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Tam může být pouze jeden Shipping Rule Podmínka s 0 nebo prázdnou hodnotu pro ""na hodnotu"""
+Transaction,Transakce,
+Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Poznámka: Tento Nákladové středisko je Group. Nelze vytvořit účetní zápisy proti skupinám.
+Tools,Nástroje,
+Valid For Territories,Platí pro územe,
+Website Item Groups,Webové stránky skupiny položek,
+Production order number is mandatory for stock entry purpose manufacture,Výrobní číslo objednávky je povinná pro legální vstup účelem výroby,
+Total (Company Currency),Total (Company měny)
+Applicable Territory,Použitelné Oblasti,
+Serial number {0} entered more than once,Výrobní číslo {0} přihlášeno více než jednou,
+Journal Entry,Zápis do deníku,
+Workstation Name,Meno pracovnej stanice,
+Email Digest:,E-mail Digest:
+BOM {0} does not belong to Item {1},BOM {0} nepatří k bodu {1}
+Target Distribution,Target Distribution,
+Comments,Komentáře,
+Bank Account No.,Bankovní účet č.
+This is the number of the last created transaction with this prefix,To je číslo poslední vytvořené transakci s tímto prefixem,
+Valuation Rate required for Item {0},Ocenění Rate potřebný k bodu {0}
+Reading 8,Čtení 8,
+Agent,Agent,
+"Total {0} for all items is zero, may you should change 'Distribute Charges Based On'","Celkem {0} pro všechny položky je nula, můžete měli změnit &quot;Distribuovat poplatků na základě&quot;"
+Taxes and Charges Calculation,Daně a poplatky výpočet,
+Workstation,pracovna stanica,
+Hardware,Technické vybavent,
+HR Manager,HR Manager,
+Privilege Leave,Privilege Leave,
+Supplier Invoice Date,Dodavatelské faktury Datum,
+You need to enable Shopping Cart,Musíte povolit Nákupní košík,
+No Data,No Data,
+Appraisal Template Goal,Posouzení Template Goal,
+Earning,Získávánt,
+Add or Deduct,Přidat nebo Odečíst,
+Overlapping conditions found between:,Překrývající podmínky nalezeno mezi:
+Against Journal Entry {0} is already adjusted against some other voucher,Proti věstníku Entry {0} je již nastavena proti jiným poukaz,
+Files Folder ID,ID složeky souborz,
+Total Order Value,Celková hodnota objednávky,
+Item Variants {0} deleted,Bod Varianty {0} vypouštz,
+Food,Jídlo,
+Ageing Range 3,Stárnutí Rozsah 3,
+You can make a time log only against a submitted production order,Můžete udělat časový záznam pouze proti předložené výrobní objednávce,
+No of Visits,Počet návštěv,
+old_parent,old_parent,
+"Newsletters to contacts, leads.","Zpravodaje ke kontaktům, vede."
+Sum of points for all goals should be 100. It is {0},Součet bodů za všech cílů by mělo být 100. Je {0}
+Operations cannot be left blank.,Operace nemůže být prázdné.
+Delivered Items To Be Billed,Dodávaných výrobků fakturovaných,
+Warehouse cannot be changed for Serial No.,Warehouse nemůže být změněn pro Serial No.
+Status updated to {0},Status aktualizován na {0}
+Description,Popis,
+Average Discount,Průměrná sleva,
+Backup Manager,Správce zálohováns,
+Is Default,Je Výchozs,
+Utilities,Utilities,
+Accounting,Účetnictvs,
+Features Setup,Nastavení Funkcs,
+View Offer Letter,View Nabídka Dopis,
+Sales BOM,Sales BOM,
+Communication,Komunikace,
+Is Service Item,Je Service Item,
+Projects,Projekty,
+Please select Fiscal Year,"Prosím, vyberte Fiskální rok"
+From {0} | {1} {2},Od {0} | {1} {2}
+Operation Description,Operace Popis,
+Will also apply to variants,Bude se vztahovat i na varianty,
+Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,"Nelze měnit Fiskální rok Datum zahájení a fiskální rok datum ukončení, jakmile fiskální rok se uloží."
+Shopping Cart,Nákupní vozík,
+Avg Daily Outgoing,Avg Daily Odchozk,
+Campaign,Kampak,
+Approval Status must be 'Approved' or 'Rejected',"Stav schválení musí být ""schváleno"" nebo ""Zamítnuto"""
+Sales BOM Help,Sales BOM Help,
+Contact Person,Kontaktní osoba,
+'Expected Start Date' can not be greater than 'Expected End Date',"""Očekávaný Datum Začátku"" nemůže být větší než ""Očekávanou Datum Konce"""
+Holidays,Prázdniny,
+Planned Quantity,Plánované Množstvy,
+Item Tax Amount,Částka Daně Položky,
+Get Terms and Conditions,Získejte Smluvní podmínky,
+Leave blank if considered for all designations,"Ponechte prázdné, pokud se to považuje za všechny označení"
+Charge of type 'Actual' in row {0} cannot be included in Item Rate,"Obvinění z typu ""Aktuální"" v řádku {0} nemůže být zařazena do položky Rate"
+Max: {0},Max: {0}
+From Datetime,Od datetime,
+For Company,Pro Společnost,
+Communication log.,Komunikační protokol.
+Buying Amount,Nákup Částka,
+Shipping Address Name,Přepravní Adresa Název,
+Chart of Accounts,Diagram účta,
+Terms and Conditions Content,Podmínky Content,
+cannot be greater than 100,nemůže být větší než 100,
+Discount  %,Sleva%
+Item {0} is not a stock Item,Položka {0} není skladem,
+Unscheduled,Neplánovanm,
+Owned,Vlastník,
+"Higher the number, higher the priority","Vyšší číslo, vyšší priorita"
+Purchase Invoice Trends,Trendy přijatách faktur,
+Better Prospects,Lepší vyhlídky,
+Goals,Cíle,
+Warranty / AMC Status,Záruka / AMC Status,
+Accounts Browser,Účty Browser,
+GL Entry,Vstup GL,
+Employee Settings,Nastavení zaměstnancr,
+Batch-Wise Balance History,Batch-Wise Balance History,
+To Do List,Do List,
+Apprentice,Učer,
+Negative Quantity is not allowed,Negativní množství není dovoleno,
+"Tax detail table fetched from item master as a string and stored in this field.
 Used for Taxes and Charges","Tax detail tabulka staženy z položky pána jako řetězec a uložené v této oblasti.
  Používá se daní a poplatků"
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +60,Lancing,Lancing
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +147,Employee cannot report to himself.,Zaměstnanec nemůže odpovídat sám sobě.
-DocType: Account,"If the account is frozen, entries are allowed to restricted users.","V případě, že účet je zamrzlý, položky mohou omezeným uživatelům."
-DocType: Job Opening,"Job profile, qualifications required etc.","Profil Job, požadované kvalifikace atd."
-DocType: Journal Entry Account,Account Balance,Zůstatek na účtu
-DocType: Rename Tool,Type of document to rename.,Typ dokumentu přejmenovat.
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +578,We buy this Item,Vykupujeme tuto položku
-DocType: Address,Billing,Fakturace
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +76,Flanging,Obrubování
-DocType: Bulk Email,Not Sent,Neodesláno
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +72,Explosive forming,Výbušné tváření
-DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Celkem Daně a poplatky (Company Měnové)
-DocType: Shipping Rule,Shipping Account,Přepravní účtu
-apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +41,Scheduled to send to {0} recipients,Plánované poslat na {0} příjemci
-DocType: Quality Inspection,Readings,Čtení
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +571,Sub Assemblies,Podsestavy
-DocType: Shipping Rule Condition,To Value,Chcete-li hodnota
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +159,Source warehouse is mandatory for row {0},Source sklad je povinná pro řadu {0}
-DocType: Packing Slip,Packing Slip,Balení Slip
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Office Rent,Pronájem kanceláře
-apps/erpnext/erpnext/config/setup.py +80,Setup SMS gateway settings,Nastavení Nastavení SMS brána
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +59,Import Failed!,Import se nezdařil!
-sites/assets/js/erpnext.min.js +19,No address added yet.,Žádná adresa přidán dosud.
-DocType: Workstation Working Hour,Workstation Working Hour,Pracovní stanice Pracovní Hour
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +78,Analyst,Analytik
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +191,Row {0}: Allocated amount {1} must be less than or equals to JV amount {2},"Řádek {0}: přidělené množství {1}, musí být menší než nebo se rovná hodnotě JV {2}"
-DocType: Item,Inventory,Inventář
-DocType: Item,Sales Details,Prodejní Podrobnosti
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +148,Pinning,Připne
-DocType: Opportunity,With Items,S položkami
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +35,In Qty,V Množství
-DocType: Notification Control,Expense Claim Rejected,Uhrazení výdajů zamítnuto
-DocType: Sales Invoice,"The date on which next invoice will be generated. It is generated on submit.
+Lancing,Lancing,
+Employee cannot report to himself.,Zaměstnanec nemůže odpovídat sám sobě.
+"If the account is frozen, entries are allowed to restricted users.","V případě, že účet je zamrzlý, položky mohou omezeným uživatelům."
+"Job profile, qualifications required etc.","Profil Job, požadované kvalifikace atd."
+Account Balance,Zůstatek na účtu,
+Type of document to rename.,Typ dokumentu přejmenovat.
+We buy this Item,Vykupujeme tuto položku,
+Billing,Fakturace,
+Flanging,Obrubovánu,
+Not Sent,Neodesláno,
+Explosive forming,Výbušné tvářenu,
+Total Taxes and Charges (Company Currency),Celkem Daně a poplatky (Company Měnové)
+Shipping Account,Přepravní účtu,
+Scheduled to send to {0} recipients,Plánované poslat na {0} příjemci,
+Readings,Čtenu,
+Sub Assemblies,Podsestavy,
+To Value,Chcete-li hodnota,
+Source warehouse is mandatory for row {0},Source sklad je povinná pro řadu {0}
+Packing Slip,Balení Slip,
+Office Rent,Pronájem kanceláře,
+Setup SMS gateway settings,Nastavení Nastavení SMS brána,
+Import Failed!,Import se nezdařil!
+No address added yet.,Žádná adresa přidán dosud.
+Workstation Working Hour,Pracovní stanice Pracovní Hour,
+Analyst,Analytik,
+Row {0}: Allocated amount {1} must be less than or equals to JV amount {2},"Řádek {0}: přidělené množství {1}, musí být menší než nebo se rovná hodnotě JV {2}"
+Inventory,Inventái,
+Sales Details,Prodejní Podrobnosti,
+Pinning,Připne,
+With Items,S položkami,
+In Qty,V Množstvi,
+Expense Claim Rejected,Uhrazení výdajů zamítnuto,
+"The date on which next invoice will be generated. It is generated on submit.
 ","Datum, kdy bude vygenerován příští faktury. To je generován na odeslat."
-DocType: Item Attribute,Item Attribute,Položka Atribut
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +100,Government,Vláda
-DocType: Item,Re-order,Re objednávku
-DocType: Company,Services,Služby
-apps/erpnext/erpnext/accounts/report/financial_statements.py +149,Total ({0}),Celkem ({0})
-DocType: Cost Center,Parent Cost Center,Nadřazené Nákladové středisko
-DocType: Sales Invoice,Source,Zdroj
-DocType: Leave Type,Is Leave Without Pay,Je odejít bez Pay
-DocType: Purchase Order Item,"If Supplier Part Number exists for given Item, it gets stored here","Pokud dodavatel Kód existuje pro danou položku, dostane uloženy zde"
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +175,No records found in the Payment table,Nalezené v tabulce platby Žádné záznamy
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +403,Financial Year Start Date,Finanční rok Datum zahájení
-DocType: Employee External Work History,Total Experience,Celková zkušenost
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +99,Countersinking,Zahlubování
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +255,Packing Slip(s) cancelled,Balení Slip (y) zrušeno
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +96,Freight and Forwarding Charges,Nákladní a Spediční Poplatky
-DocType: Material Request Item,Sales Order No,Prodejní objednávky No
-DocType: Item Group,Item Group Name,Položka Název skupiny
-apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +47,Taken,Zaujatý
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +63,Transfer Materials for Manufacture,Přenos Materiály pro výrobu
-DocType: Pricing Rule,For Price List,Pro Ceník
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +26,Executive Search,Executive Search
-apps/erpnext/erpnext/stock/stock_ledger.py +385,"Purchase rate for item: {0} not found, which is required to book accounting entry (expense). Please mention item price against a buying price list.","Cena při platbě za položku: {0} nebyl nalezen, který je povinen si účetní položka (náklady). Prosím, uveďte zboží Cena podle seznamu kupní cenou."
-DocType: Maintenance Schedule,Schedules,Plány
-DocType: Purchase Invoice Item,Net Amount,Čistá částka
-DocType: Purchase Order Item Supplied,BOM Detail No,BOM Detail No
-DocType: Period Closing Voucher,CoA Help,CoA Help
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +533,Error: {0} > {1},Chyba: {0}> {1}
-apps/erpnext/erpnext/accounts/doctype/account/account.js +8,Please create new account from Chart of Accounts.,"Prosím, vytvořte nový účet z grafu účtů."
-DocType: Maintenance Visit,Maintenance Visit,Maintenance Visit
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +49,Customer > Customer Group > Territory,Zákazník> Zákazník Group> Territory
-DocType: Sales Invoice Item,Available Batch Qty at Warehouse,K dispozici šarže Množství ve skladu
-DocType: Time Log Batch Detail,Time Log Batch Detail,Time Log Batch Detail
-DocType: Workflow State,Tasks,úkoly
-DocType: Landed Cost Voucher,Landed Cost Help,Přistálo Náklady Help
-DocType: Event,Tuesday,Úterý
-DocType: Leave Block List,Block Holidays on important days.,Blokové Dovolená na významných dnů.
-,Accounts Receivable Summary,Pohledávky Shrnutí
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +178,Please set User ID field in an Employee record to set Employee Role,Prosím nastavte uživatelské ID pole v záznamu zaměstnanců nastavit role zaměstnance
-DocType: UOM,UOM Name,UOM Name
-DocType: Top Bar Item,Target,Cíl
-apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +33,Contribution Amount,Výše příspěvku
-DocType: Sales Invoice,Shipping Address,Shipping Address
-DocType: Stock Reconciliation,This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,"Tento nástroj vám pomůže aktualizovat nebo opravit množství a ocenění zásob v systému. To se obvykle používá k synchronizaci hodnot systému a to, co ve skutečnosti existuje ve vašich skladech."
-DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,"Ve slovech budou viditelné, jakmile uložíte doručení poznámku."
-apps/erpnext/erpnext/config/stock.py +120,Brand master.,Master Značky
-DocType: ToDo,Due Date,Datum splatnosti
-DocType: Sales Invoice Item,Brand Name,Jméno značky
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +574,Box,Krabice
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +387,The Organization,Organizace
-DocType: Monthly Distribution,Monthly Distribution,Měsíční Distribution
-apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +66,Receiver List is empty. Please create Receiver List,Přijímač Seznam je prázdný. Prosím vytvořte přijímače Seznam
-DocType: Production Plan Sales Order,Production Plan Sales Order,Výrobní program prodejní objednávky
-DocType: Sales Partner,Sales Partner Target,Sales Partner Target
-DocType: Pricing Rule,Pricing Rule,Ceny Pravidlo
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +57,Notching,Vystřihování
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +44,Reserved warehouse required for stock item {0},Vyhrazeno sklad potřebný pro živočišnou položku {0}
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16,Bank Accounts,Bankovní účty
-,Bank Reconciliation Statement,Bank Odsouhlasení prohlášení
-DocType: Address,Lead Name,Olovo Name
-,POS,POS
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +14,{0} must appear only once,{0} musí být uvedeny pouze jednou
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +371,Not allowed to tranfer more {0} than {1} against Purchase Order {2},"Není povoleno, aby transfer více {0} než {1} proti Objednávky {2}"
-apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +58,Leaves Allocated Successfully for {0},Listy Přidělené úspěšně za {0}
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +40,No Items to pack,Žádné položky k balení
-DocType: Shipping Rule Condition,From Value,Od hodnoty
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +579,Manufacturing Quantity is mandatory,Výrobní množství je povinné
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +41,Amounts not reflected in bank,Částky nezohledněny v bance
-DocType: Quality Inspection Reading,Reading 4,Čtení 4
-apps/erpnext/erpnext/config/hr.py +23,Claims for company expense.,Nároky na náklady firmy.
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +7,Centrifugal casting,Odstředivé lití
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +118,Magnetic field-assisted finishing,Magnetické pole-assisted dokončování
-DocType: Company,Default Holiday List,Výchozí Holiday Seznam
-apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +227,Task is Mandatory if Time Log is against a project,"Úkol je povinné, pokud Time Log je proti projektu"
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +165,Stock Liabilities,Stock Závazky
-DocType: Purchase Receipt,Supplier Warehouse,Dodavatel Warehouse
-DocType: Opportunity,Contact Mobile No,Kontakt Mobil
-DocType: Production Planning Tool,Select Sales Orders,Vyberte Prodejní objednávky
-,Material Requests for which Supplier Quotations are not created,Materiál Žádosti o které Dodavatel citace nejsou vytvořeny
-DocType: Features Setup,To track items using barcode. You will be able to enter items in Delivery Note and Sales Invoice by scanning barcode of item.,Chcete-li sledovat položky pomocí čárového kódu. Budete mít možnost zadat položky dodacího listu a prodejní faktury snímáním čárového kódu položky.
-apps/erpnext/erpnext/crm/doctype/lead/lead.js +34,Make Quotation,Značka Citace
-DocType: Dependent Task,Dependent Task,Závislý Task
-apps/erpnext/erpnext/stock/doctype/item/item.py +291,Conversion factor for default Unit of Measure must be 1 in row {0},"Konverzní faktor pro výchozí měrnou jednotku, musí být 1 v řádku {0}"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +193,You can not enter both Delivery Note No and Sales Invoice No. Please enter any one.,"Nelze zadat i dodací list č a prodejní faktury č Prosím, zadejte jednu."
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +142,Leave of type {0} cannot be longer than {1},Leave typu {0} nemůže být delší než {1}
-DocType: Manufacturing Settings,Try planning operations for X days in advance.,Zkuste plánování operací pro X dní předem.
-DocType: HR Settings,Stop Birthday Reminders,Zastavit připomenutí narozenin
-DocType: SMS Center,Receiver List,Přijímač Seznam
-DocType: Payment Tool Detail,Payment Amount,Částka platby
-apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Spotřebovaném množství
-DocType: Salary Structure Deduction,Salary Structure Deduction,Plat Struktura Odpočet
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +157,Selective laser sintering,Selektivní laserové spékání
-apps/erpnext/erpnext/stock/doctype/item/item.py +286,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Měrná jednotka {0} byl zadán více než jednou v konverzním faktorem tabulce
-apps/frappe/frappe/core/page/data_import_tool/data_import_tool.js +74,Import Successful!,Import byl úspěšný!
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Náklady na vydaných položek
-DocType: Email Digest,Expenses Booked,Náklady rezervováno
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +168,Quantity must not be more than {0},Množství nesmí být větší než {0}
-DocType: Quotation Item,Quotation Item,Položka Nabídky
-DocType: Account,Account Name,Název účtu
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +34,From Date cannot be greater than To Date,Datum OD nemůže být vetší než datum DO
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +209,Serial No {0} quantity {1} cannot be a fraction,Pořadové číslo {0} {1} množství nemůže být zlomek
-apps/erpnext/erpnext/config/buying.py +59,Supplier Type master.,Dodavatel Type master.
-DocType: Purchase Order Item,Supplier Part Number,Dodavatel Číslo dílu
-apps/frappe/frappe/core/page/permission_manager/permission_manager.js +372,Add,Přidat
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +87,Conversion rate cannot be 0 or 1,Míra konverze nemůže být 0 nebo 1
-DocType: Accounts Settings,Credit Controller,Credit Controller
-DocType: Delivery Note,Vehicle Dispatch Date,Vozidlo Dispatch Datum
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +56,Task is mandatory if Expense Claim is against a Project,"Úkol je povinné, pokud Náklady Reklamace je proti projektu"
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +196,Purchase Receipt {0} is not submitted,Doklad o koupi {0} není předložena
-DocType: Company,Default Payable Account,Výchozí Splatnost účtu
-DocType: Party Type,Contacts,Kontakty
-apps/erpnext/erpnext/config/website.py +13,"Settings for online shopping cart such as shipping rules, price list etc.","Nastavení pro on-line nákupního košíku, jako jsou pravidla dopravu, ceník atd"
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +601,Setup Complete,Setup Complete
-apps/erpnext/erpnext/controllers/website_list_for_contact.py +48,{0}% Billed,{0}% Účtovaný
-apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +33,Reserved Qty,Reserved Množství
-DocType: Party Account,Party Account,Party účtu
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +69,Human Resources,Lidské zdroje
-DocType: Lead,Upper Income,Horní příjmů
-apps/erpnext/erpnext/support/doctype/issue/issue.py +52,My Issues,Moje problémy
-DocType: BOM Item,BOM Item,BOM Item
-DocType: Appraisal,For Employee,Pro zaměstnance
-apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +188,Row {0}: Payment amount can not be negative,Row {0}: Částka platby nemůže být záporný
-DocType: Expense Claim,Total Amount Reimbursed,Celkové částky proplacené
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +151,Press fitting,Tisková kování
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +60,Against Supplier Invoice {0} dated {1},Proti faktuře dodavatele {0} ze dne {1}
-DocType: Party Type,Default Price List,Výchozí Ceník
-DocType: Journal Entry,User Remark will be added to Auto Remark,Uživatel Poznámka budou přidány do Auto Poznámka
-DocType: Payment Reconciliation,Payments,Platby
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +23,Hot isostatic pressing,Izostatické lisování
-DocType: ToDo,Medium,Střední
-DocType: Budget Detail,Budget Allocated,Přidělený Rozpočet
-,Customer Credit Balance,Zákazník Credit Balance
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',"Zákazník požadoval pro 'Customerwise sleva """
-apps/erpnext/erpnext/config/accounts.py +53,Update bank payment dates with journals.,"Aktualizujte bankovní platební termín, časopisů."
-DocType: Quotation,Term Details,Termín Podrobnosti
-DocType: Manufacturing Settings,Capacity Planning For (Days),Plánování kapacit Pro (dny)
-DocType: Warranty Claim,Warranty Claim,Záruční reklamace
-,Lead Details,Olověné Podrobnosti
-DocType: Authorization Rule,Approving User,Schvalování Uživatel
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +36,Forging,Kování
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +125,Plating,Pokovování
-DocType: Purchase Invoice,End date of current invoice's period,Datum ukončení doby aktuální faktury je
-DocType: Pricing Rule,Applicable For,Použitelné pro
-DocType: Bank Reconciliation,From Date,Od data
-DocType: Backup Manager,Validate,Potvrdit
-DocType: Maintenance Visit,Partially Completed,Částečně Dokončeno
-DocType: Sales Invoice,Packed Items,Zabalené položky
-apps/erpnext/erpnext/config/support.py +18,Warranty Claim against Serial No.,Reklamační proti sériového čísla
-DocType: BOM Replace Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM","Nahradit konkrétní kusovník ve všech ostatních kusovníky, kde se používá. To nahradí původní odkaz kusovníku, aktualizujte náklady a regenerovat ""BOM explozi položku"" tabulku podle nového BOM"
-DocType: Shopping Cart Settings,Enable Shopping Cart,Povolit Nákupní košík
-DocType: Employee,Permanent Address,Trvalé bydliště
-apps/erpnext/erpnext/stock/get_item_details.py +123,Item {0} must be a Service Item.,Položka {0} musí být služba položky.
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +158,Please select item code,"Prosím, vyberte položku kód"
-DocType: Salary Structure Deduction,Reduce Deduction for Leave Without Pay (LWP),Snížit Odpočet o dovolenou bez nároku na odměnu (LWP)
-DocType: Territory,Territory Manager,Oblastní manažer
-DocType: Selling Settings,Selling Settings,Prodejní Nastavení
-apps/erpnext/erpnext/stock/doctype/item/item.py +155,Item cannot be a variant of a variant,Položka nemůže být varianta varianty
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +38,Online Auctions,Aukce online
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +89,Please specify either Quantity or Valuation Rate or both,"Uveďte prosím buď Množství nebo ocenění Cena, nebo obojí"
-apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.js +36,"Company, Month and Fiscal Year is mandatory","Společnost, měsíc a fiskální rok je povinný"
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Marketing Expenses,Marketingové náklady
-,Item Shortage Report,Položka Nedostatek Report
-apps/erpnext/erpnext/stock/doctype/item/item.js +208,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Hmotnost je uvedeno, \n uveďte prosím ""váha UOM"" příliš"
-DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Materiál Žádost používá k výrobě této populace Entry
-DocType: Journal Entry,View Details,Zobrazit podrobnosti
-apps/erpnext/erpnext/config/support.py +43,Single unit of an Item.,Single jednotka položky.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +160,Time Log Batch {0} must be 'Submitted',"Time Log Batch {0} musí být ""Odesláno"""
-DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Ujistěte se účetní položka pro každý pohyb zásob
-DocType: Leave Allocation,Total Leaves Allocated,Celkem Leaves Přidělené
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +334,Warehouse required at Row No {0},Warehouse vyžadováno při Row No {0}
-DocType: Employee,Date Of Retirement,Datum odchodu do důchodu
-DocType: Upload Attendance,Get Template,Získat šablonu
-DocType: Address,Postal,Poštovní
-DocType: Email Digest,Total amount of invoices sent to the customer during the digest period,Celková částka faktury poslal k zákazníkovi v období digest
-DocType: Item,Weightage,Weightage
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +158,Mining,Hornictví
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +16,Resin casting,Resin lití
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +79,A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Zákaznická Skupina existuje se stejným názvem, prosím změnit název zákazníka nebo přejmenujte skupinu zákazníků"
-DocType: Territory,Parent Territory,Parent Territory
-DocType: Quality Inspection Reading,Reading 2,Čtení 2
-DocType: Stock Entry,Material Receipt,Příjem materiálu
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +570,Products,Výrobky
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +41,Party Type and Party is required for Receivable / Payable account {0},Zadejte Party Party a je nutné pro pohledávky / závazky na účtu {0}
-DocType: Lead,Next Contact By,Další Kontakt By
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +218,Quantity required for Item {0} in row {1},Množství požadované pro bodě {0} v řadě {1}
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +85,Warehouse {0} can not be deleted as quantity exists for Item {1},"Sklad {0} nelze smazat, protože existuje množství k položce {1}"
-DocType: Quotation,Order Type,Typ objednávky
-DocType: Purchase Invoice,Notification Email Address,Oznámení e-mailová adresa
-DocType: Payment Tool,Find Invoices to Match,Najít faktury zápas
-,Item-wise Sales Register,Item-moudrý Sales Register
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +397,"e.g. ""XYZ National Bank""","např ""XYZ Národní Banka"""
-DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Je to poplatek v ceně základní sazbě?
-apps/erpnext/erpnext/selling/report/territory_target_variance_item_group_wise/territory_target_variance_item_group_wise.py +57,Total Target,Celkem Target
-DocType: Job Applicant,Applicant for a Job,Žadatel o zaměstnání
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +178,No Production Orders created,Žádné výrobní zakázky vytvořené
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +131,Salary Slip of employee {0} already created for this month,Plat Slip of zaměstnance {0} již vytvořili pro tento měsíc
-DocType: Stock Reconciliation,Reconciliation JSON,Odsouhlasení JSON
-apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,Příliš mnoho sloupců. Export zprávu a vytiskněte jej pomocí aplikace tabulky.
-DocType: Sales Invoice Item,Batch No,Č. šarže
-apps/erpnext/erpnext/setup/doctype/company/company.py +142,Main,Hlavní
-DocType: DocPerm,Delete,Smazat
-apps/erpnext/erpnext/stock/doctype/item/item_list.js +11,Variant,Varianta
-sites/assets/js/desk.min.js +836,New {0},Nový: {0}
-DocType: Naming Series,Set prefix for numbering series on your transactions,Nastavit prefix pro číslování série na vašich transakcí
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +154,Stopped order cannot be cancelled. Unstop to cancel.,Zastaveno příkaz nelze zrušit. Uvolnit zrušit.
-apps/erpnext/erpnext/stock/doctype/item/item.py +308,Default BOM ({0}) must be active for this item or its template,Výchozí BOM ({0}) musí být aktivní pro tuto položku nebo jeho šablony
-DocType: Employee,Leave Encashed?,Ponechte zpeněžení?
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +31,Opportunity From field is mandatory,Opportunity Ze hřiště je povinné
-DocType: Sales Invoice,Considered as an Opening Balance,Považována za počáteční zůstatek
-DocType: Item,Variants,Varianty
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.js +468,Make Purchase Order,Proveďte objednávky
-DocType: SMS Center,Send To,Odeslat
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +111,There is not enough leave balance for Leave Type {0},Není dost bilance dovolenou na vstup typ {0}
-DocType: Sales Team,Contribution to Net Total,Příspěvek na celkových čistých
-DocType: Sales Invoice Item,Customer's Item Code,Zákazníka Kód položky
-DocType: Stock Reconciliation,Stock Reconciliation,Reklamní Odsouhlasení
-DocType: Territory,Territory Name,Území Name
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +143,Work-in-Progress Warehouse is required before Submit,Work-in-Progress sklad je zapotřebí před Odeslat
-apps/erpnext/erpnext/config/hr.py +43,Applicant for a Job.,Žadatel o zaměstnání.
-DocType: Sales Invoice Item,Warehouse and Reference,Sklad a reference
-DocType: Supplier,Statutory info and other general information about your Supplier,Statutární info a další obecné informace o váš dodavatel
-DocType: Country,Country,Země
-apps/erpnext/erpnext/shopping_cart/utils.py +48,Addresses,Adresy
-DocType: Communication,Received,Přijato
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +156,Against Journal Entry {0} does not have any unmatched {1} entry,Proti věstníku Vstup {0} nemá bezkonkurenční {1} vstupu
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +216,Duplicate Serial No entered for Item {0},Duplicitní Pořadové číslo vstoupil k bodu {0}
-DocType: Shipping Rule Condition,A condition for a Shipping Rule,Podmínka pro pravidla dopravy
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +201,"Name of new Account. Note: Please don't create accounts for Customers and Suppliers, they are created automatically from the Customer and Supplier master","Název nového účtu. Poznámka: Prosím, vytvářet účty pro zákazníky a dodavatele, které se automaticky vytvoří z zákazníkem a dodavatelem master"
-DocType: DocField,Attach Image,Připojit obrázek
-DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Čistá hmotnost tohoto balíčku. (Automaticky vypočítá jako součet čisté váhy položek)
-DocType: Stock Reconciliation Item,Leave blank if no change,"Ponechte prázdné, pokud žádná změna"
-apps/erpnext/erpnext/config/manufacturing.py +24,Time Logs for manufacturing.,Čas Protokoly pro výrobu.
-DocType: Item,Apply Warehouse-wise Reorder Level,Použít Skladovací-moudrý Seřadit sezn Level
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +426,BOM {0} must be submitted,BOM {0} musí být předloženy
-DocType: Authorization Control,Authorization Control,Autorizace Control
-apps/erpnext/erpnext/config/projects.py +23,Time Log for tasks.,Time Log pro úkoly.
-DocType: Production Order Operation,Actual Time and Cost,Skutečný Čas a Náklady
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +52,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Materiál Žádost maximálně {0} lze k bodu {1} na odběratele {2}
-DocType: Employee,Salutation,Oslovení
-DocType: Offer Letter,Rejected,Zamítnuto
-DocType: Pricing Rule,Brand,Značka
-DocType: Item,Will also apply for variants,Bude platit i pro varianty
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +609,% Delivered,% Dodáno
-apps/erpnext/erpnext/config/selling.py +148,Bundle items at time of sale.,Bundle položky v okamžiku prodeje.
-DocType: Sales Order Item,Actual Qty,Skutečné Množství
-DocType: Quality Inspection Reading,Reading 10,Čtení 10
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +560,"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.","Seznam vaše produkty nebo služby, které jste koupit nebo prodat. Ujistěte se, že zkontrolovat položky Group, měrná jednotka a dalších vlastností při spuštění."
-DocType: Hub Settings,Hub Node,Hub Node
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,"Zadali jste duplicitní položky. Prosím, opravu a zkuste to znovu."
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +82,Associate,Spolupracovník
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +46,Item {0} is not a serialized Item,Položka {0} není serializovat položky
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +573,"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.","Pro ""Sales BOM"" předměty, sklad, bude Serial No a Batch No považují z ""Obsah balení"" tabulky. Pokud Warehouse a Batch No jsou stejné u všech balení předměty pro každého ""Prodej BOM"" položky, tyto hodnoty mohou být zapsány do hlavní tabulky položky, hodnoty se budou zkopírovány do ""Obsah balení"" tabulky."
-DocType: SMS Center,Create Receiver List,Vytvořit přijímače seznam
-apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +5,Expired,Vypršela
-DocType: Packing Slip,To Package No.,Balit No.
-DocType: DocType,System,Systém
-DocType: Warranty Claim,Issue Date,Datum vydání
-DocType: Activity Cost,Activity Cost,Náklady Aktivita
-DocType: Purchase Receipt Item Supplied,Consumed Qty,Spotřeba Množství
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +51,Telecommunications,Telekomunikace
-DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),"Označuje, že balíček je součástí této dodávky (Pouze návrhu)"
-DocType: Payment Tool,Make Payment Entry,Učinit vstup platby
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +119,Quantity for Item {0} must be less than {1},Množství k bodu {0} musí být menší než {1}
-DocType: Backup Manager,Never,Nikdy
-,Sales Invoice Trends,Prodejní faktury Trendy
-DocType: Leave Application,Apply / Approve Leaves,Použít / Schválit listy
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +90,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Se může vztahovat řádku, pouze pokud typ poplatku je ""On předchozí řady Částka"" nebo ""předchozí řady Total"""
-DocType: Item,Allowance Percent,Allowance Procento
-DocType: SMS Settings,Message Parameter,Parametr zpráv
-DocType: Serial No,Delivery Document No,Dodávka dokument č
-DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Získat položky z Příjmového listu
-DocType: Serial No,Creation Date,Datum vytvoření
-apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +34,Item {0} appears multiple times in Price List {1},Položka {0} se objeví několikrát v Ceníku {1}
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37,"Selling must be checked, if Applicable For is selected as {0}","Prodej musí být zkontrolováno, v případě potřeby pro vybrán jako {0}"
-DocType: Purchase Order Item,Supplier Quotation Item,Dodavatel Nabídka Položka
-apps/erpnext/erpnext/hr/doctype/employee/employee.js +27,Make Salary Structure,Proveďte platovou strukturu
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +53,Shearing,Stříhání
-DocType: Item,Has Variants,Má varianty
-apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +22,Click on 'Make Sales Invoice' button to create a new Sales Invoice.,"Klikněte na tlačítko "", aby se prodej na faktuře"" vytvořit nový prodejní faktury."
-apps/erpnext/erpnext/controllers/recurring_document.py +164,Period From and Period To dates mandatory for recurring %s,"Období od a období, na termíny povinných opakujících% s"
-DocType: Journal Entry Account,Against Expense Claim,Proti Expense nároku
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +165,Packaging and labeling,Balení a označování
-DocType: Monthly Distribution,Name of the Monthly Distribution,Název měsíční výplatou
-DocType: Sales Person,Parent Sales Person,Parent obchodník
-apps/erpnext/erpnext/setup/utils.py +14,Please specify Default Currency in Company Master and Global Defaults,"Uveďte prosím výchozí měnu, ve společnosti Master and Global výchozí"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +221,"Payment against {0} {1} cannot be greater \
+Item Attribute,Položka Atribut,
+Government,Vláda,
+Re-order,Re objednávku,
+Services,Služby,
+Total ({0}),Celkem ({0})
+Parent Cost Center,Nadřazené Nákladové středisko,
+Source,Zdroj,
+Is Leave Without Pay,Je odejít bez Pay,
+"If Supplier Part Number exists for given Item, it gets stored here","Pokud dodavatel Kód existuje pro danou položku, dostane uloženy zde"
+No records found in the Payment table,Nalezené v tabulce platby Žádné záznamy,
+Financial Year Start Date,Finanční rok Datum zahájeny,
+Total Experience,Celková zkušenost,
+Countersinking,Zahlubovány,
+Packing Slip(s) cancelled,Balení Slip (y) zrušeno,
+Freight and Forwarding Charges,Nákladní a Spediční Poplatky,
+Sales Order No,Prodejní objednávky No,
+Item Group Name,Položka Název skupiny,
+Taken,Zaujaty,
+Transfer Materials for Manufacture,Přenos Materiály pro výrobu,
+For Price List,Pro Ceník,
+Executive Search,Executive Search,
+"Purchase rate for item: {0} not found, which is required to book accounting entry (expense). Please mention item price against a buying price list.","Cena při platbě za položku: {0} nebyl nalezen, který je povinen si účetní položka (náklady). Prosím, uveďte zboží Cena podle seznamu kupní cenou."
+Schedules,Plány,
+Net Amount,Čistá částka,
+BOM Detail No,BOM Detail No,
+CoA Help,CoA Help,
+Error: {0} > {1},Chyba: {0}> {1}
+Please create new account from Chart of Accounts.,"Prosím, vytvořte nový účet z grafu účtů."
+Maintenance Visit,Maintenance Visit,
+Customer > Customer Group > Territory,Zákazník> Zákazník Group> Territory,
+Available Batch Qty at Warehouse,K dispozici šarže Množství ve skladu,
+Time Log Batch Detail,Time Log Batch Detail,
+Tasks,úkoly,
+Landed Cost Help,Přistálo Náklady Help,
+Tuesday,Útert,
+Block Holidays on important days.,Blokové Dovolená na významných dnů.
+Accounts Receivable Summary,Pohledávky Shrnute,
+Please set User ID field in an Employee record to set Employee Role,Prosím nastavte uživatelské ID pole v záznamu zaměstnanců nastavit role zaměstnance,
+UOM Name,UOM Name,
+Target,Cíl,
+Contribution Amount,Výše příspěvku,
+Shipping Address,Shipping Address,
+This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,"Tento nástroj vám pomůže aktualizovat nebo opravit množství a ocenění zásob v systému. To se obvykle používá k synchronizaci hodnot systému a to, co ve skutečnosti existuje ve vašich skladech."
+In Words will be visible once you save the Delivery Note.,"Ve slovech budou viditelné, jakmile uložíte doručení poznámku."
+Brand master.,Master Značky,
+Due Date,Datum splatnosti,
+Brand Name,Jméno značky,
+Box,Krabice,
+The Organization,Organizace,
+Monthly Distribution,Měsíční Distribution,
+Receiver List is empty. Please create Receiver List,Přijímač Seznam je prázdný. Prosím vytvořte přijímače Seznam,
+Production Plan Sales Order,Výrobní program prodejní objednávky,
+Sales Partner Target,Sales Partner Target,
+Pricing Rule,Ceny Pravidlo,
+Notching,Vystřihovány,
+Reserved warehouse required for stock item {0},Vyhrazeno sklad potřebný pro živočišnou položku {0}
+Bank Accounts,Bankovní účty,
+Bank Reconciliation Statement,Bank Odsouhlasení prohlášeny,
+Lead Name,Olovo Name,
+POS,POS,
+{0} must appear only once,{0} musí být uvedeny pouze jednou,
+Not allowed to tranfer more {0} than {1} against Purchase Order {2},"Není povoleno, aby transfer více {0} než {1} proti Objednávky {2}"
+Leaves Allocated Successfully for {0},Listy Přidělené úspěšně za {0}
+No Items to pack,Žádné položky k baleny,
+From Value,Od hodnoty,
+Manufacturing Quantity is mandatory,Výrobní množství je povinny,
+Amounts not reflected in bank,Částky nezohledněny v bance,
+Reading 4,Čtení 4,
+Claims for company expense.,Nároky na náklady firmy.
+Centrifugal casting,Odstředivé litm,
+Magnetic field-assisted finishing,Magnetické pole-assisted dokončovánm,
+Default Holiday List,Výchozí Holiday Seznam,
+Task is Mandatory if Time Log is against a project,"Úkol je povinné, pokud Time Log je proti projektu"
+Stock Liabilities,Stock Závazky,
+Supplier Warehouse,Dodavatel Warehouse,
+Contact Mobile No,Kontakt Mobil,
+Select Sales Orders,Vyberte Prodejní objednávky,
+Material Requests for which Supplier Quotations are not created,Materiál Žádosti o které Dodavatel citace nejsou vytvořeny,
+To track items using barcode. You will be able to enter items in Delivery Note and Sales Invoice by scanning barcode of item.,Chcete-li sledovat položky pomocí čárového kódu. Budete mít možnost zadat položky dodacího listu a prodejní faktury snímáním čárového kódu položky.
+Make Quotation,Značka Citace,
+Dependent Task,Závislý Task,
+Conversion factor for default Unit of Measure must be 1 in row {0},"Konverzní faktor pro výchozí měrnou jednotku, musí být 1 v řádku {0}"
+You can not enter both Delivery Note No and Sales Invoice No. Please enter any one.,"Nelze zadat i dodací list č a prodejní faktury č Prosím, zadejte jednu."
+Leave of type {0} cannot be longer than {1},Leave typu {0} nemůže být delší než {1}
+Try planning operations for X days in advance.,Zkuste plánování operací pro X dní předem.
+Stop Birthday Reminders,Zastavit připomenutí narozenin,
+Receiver List,Přijímač Seznam,
+Payment Amount,Částka platby,
+Consumed Amount,Spotřebovaném množstvn,
+Salary Structure Deduction,Plat Struktura Odpočet,
+Selective laser sintering,Selektivní laserové spékánn,
+Unit of Measure {0} has been entered more than once in Conversion Factor Table,Měrná jednotka {0} byl zadán více než jednou v konverzním faktorem tabulce,
+Import Successful!,Import byl úspěšný!
+Cost of Issued Items,Náklady na vydaných položek,
+Expenses Booked,Náklady rezervováno,
+Quantity must not be more than {0},Množství nesmí být větší než {0}
+Quotation Item,Položka Nabídky,
+Account Name,Název účtu,
+From Date cannot be greater than To Date,Datum OD nemůže být vetší než datum DO,
+Serial No {0} quantity {1} cannot be a fraction,Pořadové číslo {0} {1} množství nemůže být zlomek,
+Supplier Type master.,Dodavatel Type master.
+Supplier Part Number,Dodavatel Číslo dílu,
+Add,Přidat,
+Conversion rate cannot be 0 or 1,Míra konverze nemůže být 0 nebo 1,
+Credit Controller,Credit Controller,
+Vehicle Dispatch Date,Vozidlo Dispatch Datum,
+Task is mandatory if Expense Claim is against a Project,"Úkol je povinné, pokud Náklady Reklamace je proti projektu"
+Purchase Receipt {0} is not submitted,Doklad o koupi {0} není předložena,
+Default Payable Account,Výchozí Splatnost účtu,
+Contacts,Kontakty,
+"Settings for online shopping cart such as shipping rules, price list etc.","Nastavení pro on-line nákupního košíku, jako jsou pravidla dopravu, ceník atd"
+Setup Complete,Setup Complete,
+{0}% Billed,{0}% Účtovane,
+Reserved Qty,Reserved Množstve,
+Party Account,Party účtu,
+Human Resources,Lidské zdroje,
+Upper Income,Horní příjme,
+My Issues,Moje problémy,
+BOM Item,BOM Item,
+For Employee,Pro zaměstnance,
+Row {0}: Payment amount can not be negative,Row {0}: Částka platby nemůže být záporne,
+Total Amount Reimbursed,Celkové částky proplacene,
+Press fitting,Tisková kováne,
+Against Supplier Invoice {0} dated {1},Proti faktuře dodavatele {0} ze dne {1}
+Default Price List,Výchozí Ceník,
+User Remark will be added to Auto Remark,Uživatel Poznámka budou přidány do Auto Poznámka,
+Payments,Platby,
+Hot isostatic pressing,Izostatické lisovánk,
+Medium,Střednk,
+Budget Allocated,Přidělený Rozpočet,
+Customer Credit Balance,Zákazník Credit Balance,
+Customer required for 'Customerwise Discount',"Zákazník požadoval pro 'Customerwise sleva """
+Update bank payment dates with journals.,"Aktualizujte bankovní platební termín, časopisů."
+Term Details,Termín Podrobnosti,
+Capacity Planning For (Days),Plánování kapacit Pro (dny)
+Warranty Claim,Záruční reklamace,
+Lead Details,Olověné Podrobnosti,
+Approving User,Schvalování Uživatel,
+Forging,Kováne,
+Plating,Pokovováne,
+End date of current invoice's period,Datum ukončení doby aktuální faktury je,
+Applicable For,Použitelné pro,
+From Date,Od data,
+Validate,Potvrdit,
+Partially Completed,Částečně Dokončeno,
+Packed Items,Zabalené položky,
+Warranty Claim against Serial No.,Reklamační proti sériového čísla,
+"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM","Nahradit konkrétní kusovník ve všech ostatních kusovníky, kde se používá. To nahradí původní odkaz kusovníku, aktualizujte náklady a regenerovat ""BOM explozi položku"" tabulku podle nového BOM"
+Enable Shopping Cart,Povolit Nákupní košík,
+Permanent Address,Trvalé bydlištk,
+Item {0} must be a Service Item.,Položka {0} musí být služba položky.
+Please select item code,"Prosím, vyberte položku kód"
+Reduce Deduction for Leave Without Pay (LWP),Snížit Odpočet o dovolenou bez nároku na odměnu (LWP)
+Territory Manager,Oblastní manažer,
+Selling Settings,Prodejní Nastavenr,
+Item cannot be a variant of a variant,Položka nemůže být varianta varianty,
+Online Auctions,Aukce online,
+Please specify either Quantity or Valuation Rate or both,"Uveďte prosím buď Množství nebo ocenění Cena, nebo obojí"
+"Company, Month and Fiscal Year is mandatory","Společnost, měsíc a fiskální rok je povinný"
+Marketing Expenses,Marketingové náklady,
+Item Shortage Report,Položka Nedostatek Report,
+"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Hmotnost je uvedeno, \n uveďte prosím ""váha UOM"" příliš"
+Material Request used to make this Stock Entry,Materiál Žádost používá k výrobě této populace Entry,
+View Details,Zobrazit podrobnosti,
+Single unit of an Item.,Single jednotka položky.
+Time Log Batch {0} must be 'Submitted',"Time Log Batch {0} musí být ""Odesláno"""
+Make Accounting Entry For Every Stock Movement,Ujistěte se účetní položka pro každý pohyb zásob,
+Total Leaves Allocated,Celkem Leaves Přidělenb,
+Warehouse required at Row No {0},Warehouse vyžadováno při Row No {0}
+Date Of Retirement,Datum odchodu do důchodu,
+Get Template,Získat šablonu,
+Postal,Poštovnu,
+Total amount of invoices sent to the customer during the digest period,Celková částka faktury poslal k zákazníkovi v období digest,
+Weightage,Weightage,
+Mining,Hornictvu,
+Resin casting,Resin litu,
+A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Zákaznická Skupina existuje se stejným názvem, prosím změnit název zákazníka nebo přejmenujte skupinu zákazníků"
+Parent Territory,Parent Territory,
+Reading 2,Čtení 2,
+Material Receipt,Příjem materiálu,
+Products,Výrobky,
+Party Type and Party is required for Receivable / Payable account {0},Zadejte Party Party a je nutné pro pohledávky / závazky na účtu {0}
+Next Contact By,Další Kontakt By,
+Quantity required for Item {0} in row {1},Množství požadované pro bodě {0} v řadě {1}
+Warehouse {0} can not be deleted as quantity exists for Item {1},"Sklad {0} nelze smazat, protože existuje množství k položce {1}"
+Order Type,Typ objednávky,
+Notification Email Address,Oznámení e-mailová adresa,
+Find Invoices to Match,Najít faktury zápas,
+Item-wise Sales Register,Item-moudrý Sales Register,
+"e.g. ""XYZ National Bank""","např ""XYZ Národní Banka"""
+Is this Tax included in Basic Rate?,Je to poplatek v ceně základní sazbě?
+Total Target,Celkem Target,
+Applicant for a Job,Žadatel o zaměstnánt,
+No Production Orders created,Žádné výrobní zakázky vytvořent,
+Salary Slip of employee {0} already created for this month,Plat Slip of zaměstnance {0} již vytvořili pro tento měsíc,
+Reconciliation JSON,Odsouhlasení JSON,
+Too many columns. Export the report and print it using a spreadsheet application.,Příliš mnoho sloupců. Export zprávu a vytiskněte jej pomocí aplikace tabulky.
+Batch No,Č. šarže,
+Main,Hlavne,
+Delete,Smazat,
+Variant,Varianta,
+New {0},Nový: {0}
+Set prefix for numbering series on your transactions,Nastavit prefix pro číslování série na vašich transakc$1,
+Stopped order cannot be cancelled. Unstop to cancel.,Zastaveno příkaz nelze zrušit. Uvolnit zrušit.
+Default BOM ({0}) must be active for this item or its template,Výchozí BOM ({0}) musí být aktivní pro tuto položku nebo jeho šablony,
+Leave Encashed?,Ponechte zpeněžení?
+Opportunity From field is mandatory,Opportunity Ze hřiště je povinnk,
+Considered as an Opening Balance,Považována za počáteční zůstatek,
+Variants,Varianty,
+Make Purchase Order,Proveďte objednávky,
+Send To,Odeslat,
+There is not enough leave balance for Leave Type {0},Není dost bilance dovolenou na vstup typ {0}
+Contribution to Net Total,Příspěvek na celkových čistých,
+Customer's Item Code,Zákazníka Kód položky,
+Stock Reconciliation,Reklamní Odsouhlasenh,
+Territory Name,Území Name,
+Work-in-Progress Warehouse is required before Submit,Work-in-Progress sklad je zapotřebí před Odeslat,
+Applicant for a Job.,Žadatel o zaměstnání.
+Warehouse and Reference,Sklad a reference,
+Statutory info and other general information about your Supplier,Statutární info a další obecné informace o váš dodavatel,
+Country,Zeme,
+Addresses,Adresy,
+Received,Přijato,
+Against Journal Entry {0} does not have any unmatched {1} entry,Proti věstníku Vstup {0} nemá bezkonkurenční {1} vstupu,
+Duplicate Serial No entered for Item {0},Duplicitní Pořadové číslo vstoupil k bodu {0}
+A condition for a Shipping Rule,Podmínka pro pravidla dopravy,
+"Name of new Account. Note: Please don't create accounts for Customers and Suppliers, they are created automatically from the Customer and Supplier master","Název nového účtu. Poznámka: Prosím, vytvářet účty pro zákazníky a dodavatele, které se automaticky vytvoří z zákazníkem a dodavatelem master"
+Attach Image,Připojit obrázek,
+The net weight of this package. (calculated automatically as sum of net weight of items),Čistá hmotnost tohoto balíčku. (Automaticky vypočítá jako součet čisté váhy položek)
+Leave blank if no change,"Ponechte prázdné, pokud žádná změna"
+Time Logs for manufacturing.,Čas Protokoly pro výrobu.
+Apply Warehouse-wise Reorder Level,Použít Skladovací-moudrý Seřadit sezn Level,
+BOM {0} must be submitted,BOM {0} musí být předloženy,
+Authorization Control,Autorizace Control,
+Time Log for tasks.,Time Log pro úkoly.
+Actual Time and Cost,Skutečný Čas a Náklady,
+Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Materiál Žádost maximálně {0} lze k bodu {1} na odběratele {2}
+Salutation,Osloveno,
+Rejected,Zamítnuto,
+Brand,Značka,
+Will also apply for variants,Bude platit i pro varianty,
+% Delivered,% Dodáno,
+Bundle items at time of sale.,Bundle položky v okamžiku prodeje.
+Actual Qty,Skutečné Množstv0,
+Reading 10,Čtení 10,
+"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.","Seznam vaše produkty nebo služby, které jste koupit nebo prodat. Ujistěte se, že zkontrolovat položky Group, měrná jednotka a dalších vlastností při spuštění."
+Hub Node,Hub Node,
+You have entered duplicate items. Please rectify and try again.,"Zadali jste duplicitní položky. Prosím, opravu a zkuste to znovu."
+Associate,Spolupracovník,
+Item {0} is not a serialized Item,Položka {0} není serializovat položky,
+"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.","Pro ""Sales BOM"" předměty, sklad, bude Serial No a Batch No považují z ""Obsah balení"" tabulky. Pokud Warehouse a Batch No jsou stejné u všech balení předměty pro každého ""Prodej BOM"" položky, tyto hodnoty mohou být zapsány do hlavní tabulky položky, hodnoty se budou zkopírovány do ""Obsah balení"" tabulky."
+Create Receiver List,Vytvořit přijímače seznam,
+Expired,Vypršela,
+To Package No.,Balit No.
+System,Systém,
+Issue Date,Datum vydánm,
+Activity Cost,Náklady Aktivita,
+Consumed Qty,Spotřeba Množstvm,
+Telecommunications,Telekomunikace,
+Indicates that the package is a part of this delivery (Only Draft),"Označuje, že balíček je součástí této dodávky (Pouze návrhu)"
+Make Payment Entry,Učinit vstup platby,
+Quantity for Item {0} must be less than {1},Množství k bodu {0} musí být menší než {1}
+Never,Nikdy,
+Sales Invoice Trends,Prodejní faktury Trendy,
+Apply / Approve Leaves,Použít / Schválit listy,
+Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Se může vztahovat řádku, pouze pokud typ poplatku je ""On předchozí řady Částka"" nebo ""předchozí řady Total"""
+Allowance Percent,Allowance Procento,
+Message Parameter,Parametr zpráv,
+Delivery Document No,Dodávka dokument o,
+Get Items From Purchase Receipts,Získat položky z Příjmového listu,
+Creation Date,Datum vytvořeno,
+Item {0} appears multiple times in Price List {1},Položka {0} se objeví několikrát v Ceníku {1}
+"Selling must be checked, if Applicable For is selected as {0}","Prodej musí být zkontrolováno, v případě potřeby pro vybrán jako {0}"
+Supplier Quotation Item,Dodavatel Nabídka Položka,
+Make Salary Structure,Proveďte platovou strukturu,
+Shearing,Stříhána,
+Has Variants,Má varianty,
+Click on 'Make Sales Invoice' button to create a new Sales Invoice.,"Klikněte na tlačítko "", aby se prodej na faktuře"" vytvořit nový prodejní faktury."
+Period From and Period To dates mandatory for recurring %s,"Období od a období, na termíny povinných opakujících% s"
+Against Expense Claim,Proti Expense nároku,
+Packaging and labeling,Balení a označovánu,
+Name of the Monthly Distribution,Název měsíční výplatou,
+Parent Sales Person,Parent obchodník,
+Please specify Default Currency in Company Master and Global Defaults,"Uveďte prosím výchozí měnu, ve společnosti Master and Global výchozí"
+"Payment against {0} {1} cannot be greater \
 					than Outstanding Amount {2}","Platba na {0} {1} nemůže být větší \
  než dlužná částka {2}"
-DocType: Backup Manager,Dropbox Access Secret,Dropbox Access Secret
-DocType: Purchase Invoice,Recurring Invoice,Opakující se faktury
-DocType: Item,Net Weight of each Item,Hmotnost každé položky
-DocType: Supplier,Supplier of Goods or Services.,Dodavatel zboží nebo služeb.
-DocType: Budget Detail,Fiscal Year,Fiskální rok
-DocType: Cost Center,Budget,Rozpočet
-apps/erpnext/erpnext/selling/report/territory_target_variance_item_group_wise/territory_target_variance_item_group_wise.py +50,Achieved,Dosažená
-apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +65,Territory / Customer,Territory / Customer
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +502,e.g. 5,např. 5
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +195,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Row {0}: Přidělená částka {1} musí být menší než nebo se rovná fakturovat dlužné částky {2}
-DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,"Ve slovech budou viditelné, jakmile uložíte prodejní faktury."
-DocType: Item,Is Sales Item,Je Sales Item
-apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21,Item Group Tree,Položka Group Tree
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +70,Item {0} is not setup for Serial Nos. Check Item master,"Položka {0} není nastavení pro Serial č. Zkontrolujte, zda master položku"
-DocType: Maintenance Visit,Maintenance Time,Údržba Time
-,Amount to Deliver,"Částka, která má dodávat"
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +568,A Product or Service,Produkt nebo Služba
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +139,There were errors.,Byly tam chyby.
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +100,Tapping,Výčepní
-DocType: Naming Series,Current Value,Current Value
-apps/erpnext/erpnext/stock/doctype/item/item.py +145,Item Template cannot have stock and varaiants. Please remove stock from warehouses {0},"Položka Šablona nemůže mít zásoby a varaiants. Prosím, odstraňte zásoby ze skladů {0}"
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +176,{0} created,{0} vytvořil
-DocType: Journal Entry Account,Against Sales Order,Proti přijaté objednávce
-,Serial No Status,Serial No Status
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +502,Item table can not be blank,Tabulka Položka nemůže být prázdný
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +148,"Row {0}: To set {1} periodicity, difference between from and to date \
+Dropbox Access Secret,Dropbox Access Secret,
+Recurring Invoice,Opakující se faktury,
+Net Weight of each Item,Hmotnost každé položky,
+Supplier of Goods or Services.,Dodavatel zboží nebo služeb.
+Fiscal Year,Fiskální rok,
+Budget,Rozpočet,
+Achieved,Dosaženk,
+Territory / Customer,Territory / Customer,
+e.g. 5,např. 5,
+Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Row {0}: Přidělená částka {1} musí být menší než nebo se rovná fakturovat dlužné částky {2}
+In Words will be visible once you save the Sales Invoice.,"Ve slovech budou viditelné, jakmile uložíte prodejní faktury."
+Is Sales Item,Je Sales Item,
+Item Group Tree,Položka Group Tree,
+Item {0} is not setup for Serial Nos. Check Item master,"Položka {0} není nastavení pro Serial č. Zkontrolujte, zda master položku"
+Maintenance Time,Údržba Time,
+Amount to Deliver,"Částka, která má dodávat"
+A Product or Service,Produkt nebo Služba,
+There were errors.,Byly tam chyby.
+Tapping,Výčepne,
+Current Value,Current Value,
+Item Template cannot have stock and varaiants. Please remove stock from warehouses {0},"Položka Šablona nemůže mít zásoby a varaiants. Prosím, odstraňte zásoby ze skladů {0}"
+{0} created,{0} vytvořil,
+Against Sales Order,Proti přijaté objednávce,
+Serial No Status,Serial No Status,
+Item table can not be blank,Tabulka Položka nemůže být prázdnl,
+"Row {0}: To set {1} periodicity, difference between from and to date \
 						must be greater than or equal to {2}","Řádek {0}: Pro nastavení {1} periodicita, rozdíl mezi z a aktuální \
  musí být větší než nebo rovno {2}"
-DocType: Pricing Rule,Selling,Prodejní
-DocType: Employee,Salary Information,Vyjednávání o platu
-DocType: Sales Person,Name and Employee ID,Jméno a ID zaměstnance
-apps/erpnext/erpnext/accounts/party.py +186,Due Date cannot be before Posting Date,Datum splatnosti nesmí být před odesláním Datum
-DocType: Website Item Group,Website Item Group,Website Item Group
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +170,Duties and Taxes,Odvody a daně
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +275,Please enter Reference date,"Prosím, zadejte Referenční den"
-DocType: Item Website Specification,Table for Item that will be shown in Web Site,"Tabulka k bodu, který se zobrazí na webových stránkách"
-DocType: Purchase Order Item Supplied,Supplied Qty,Dodávané Množství
-DocType: Material Request Item,Material Request Item,Materiál Žádost o bod
-apps/erpnext/erpnext/config/stock.py +103,Tree of Item Groups.,Strom skupiny položek.
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +100,Cannot refer row number greater than or equal to current row number for this Charge type,Nelze odkazovat číslo řádku větší nebo rovnou aktuální číslo řádku pro tento typ Charge
-,Item-wise Purchase History,Item-moudrý Historie nákupů
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +147,Red,Červená
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +237,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Prosím, klikněte na ""Generovat Schedule"", aby přinesla Pořadové číslo přidán k bodu {0}"
-DocType: Account,Frozen,Zmražený
-,Open Production Orders,Otevřené výrobní zakázky
-DocType: Installation Note,Installation Time,Instalace Time
-apps/erpnext/erpnext/setup/doctype/company/company.js +36,Delete all the Transactions for this Company,Odstraňte všechny transakce pro tuto společnost
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +204,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row # {0}: Operation {1} není dokončen {2} Množství hotových výrobků ve výrobním procesu objednávky # {3}. Prosím aktualizujte provozní stav přes čas protokoly
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +57,Investments,Investice
-DocType: Issue,Resolution Details,Rozlišení Podrobnosti
-apps/erpnext/erpnext/config/stock.py +84,Change UOM for an Item.,Změna UOM za položku.
-DocType: Quality Inspection Reading,Acceptance Criteria,Kritéria přijetí
-DocType: Item Attribute,Attribute Name,Název atributu
-apps/erpnext/erpnext/controllers/selling_controller.py +256,Item {0} must be Sales or Service Item in {1},Položka {0} musí být prodej či servis položku v {1}
-DocType: Item Group,Show In Website,Show pro webové stránky
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +569,Group,Skupina
-DocType: Task,Expected Time (in hours),Předpokládaná doba (v hodinách)
-,Qty to Order,Množství k objednávce
-DocType: Sales Order,PO No,PO No
-apps/erpnext/erpnext/config/projects.py +51,Gantt chart of all tasks.,Ganttův diagram všech zadaných úkolů.
-DocType: Appraisal,For Employee Name,Pro jméno zaměstnance
-DocType: Holiday List,Clear Table,Clear Table
-DocType: Features Setup,Brands,Značky
-DocType: C-Form Invoice Detail,Invoice No,Faktura č
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +497,From Purchase Order,Z vydané objednávky
-apps/erpnext/erpnext/accounts/party.py +139,Please select company first.,Vyberte společnost jako první.
-DocType: Activity Cost,Costing Rate,Kalkulace Rate
-DocType: Journal Entry Account,Against Journal Entry,Proti položka deníku
-DocType: Employee,Resignation Letter Date,Rezignace Letter Datum
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +37,Pricing Rules are further filtered based on quantity.,Pravidla pro stanovení sazeb jsou dále filtrována na základě množství.
-apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +137,Not Set,Není nastaveno
-DocType: Communication,Date,Datum
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Repeat Customer Příjmy
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +592,Sit tight while your system is being setup. This may take a few moments.,"Drž se, když váš systém je nastavení. To může trvat několik okamžiků."
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +46,{0} ({1}) must have role 'Expense Approver',"{0} ({1}), musí mít roli ""Schvalovatel výdajů"""
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +574,Pair,Pár
-DocType: Bank Reconciliation Detail,Against Account,Proti účet
-DocType: Maintenance Schedule Detail,Actual Date,Skutečné datum
-DocType: Item,Has Batch No,Má číslo šarže
-DocType: Delivery Note,Excise Page Number,Spotřební Číslo stránky
-DocType: Employee,Personal Details,Osobní data
-,Maintenance Schedules,Plány údržby
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +43,Embossing,Ražba
-,Quotation Trends,Uvozovky Trendy
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +135,Item Group not mentioned in item master for item {0},Položka Group není uvedeno v položce mistra na položku {0}
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +243,Debit To account must be a Receivable account,"Debetní Chcete-li v úvahu, musí být pohledávka účet"
-apps/erpnext/erpnext/stock/doctype/item/item.py +295,"As Production Order can be made for this item, it must be a stock item.","Jako výrobní objednávce lze provést za tuto položku, musí být skladem."
-DocType: Shipping Rule Condition,Shipping Amount,Přepravní Částka
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +139,Joining,Spojování
-DocType: Authorization Rule,Above Value,Výše uvedená hodnota
-,Pending Amount,Čeká Částka
-DocType: Purchase Invoice Item,Conversion Factor,Konverzní faktor
-DocType: Serial No,Delivered,Dodává
-apps/erpnext/erpnext/config/hr.py +160,Setup incoming server for jobs email id. (e.g. jobs@example.com),Nastavení příchozí server pro úlohy e-mailovou id. (Např jobs@example.com)
-DocType: Purchase Invoice,The date on which recurring invoice will be stop,"Datum, kdy opakující se faktura bude zastaví"
-DocType: Journal Entry,Accounts Receivable,Pohledávky
-,Supplier-Wise Sales Analytics,Dodavatel-Wise Prodej Analytics
-DocType: Address Template,This format is used if country specific format is not found,"Tento formát se používá, když specifický formát země není nalezen"
-DocType: Custom Field,Custom,Zvyk
-DocType: Production Order,Use Multi-Level BOM,Použijte Multi-Level BOM
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +25,Injection molding,Vstřikování
-DocType: Bank Reconciliation,Include Reconciled Entries,Zahrnout odsouhlasené zápisy
-apps/erpnext/erpnext/config/accounts.py +41,Tree of finanial accounts.,Strom finanial účtů.
-DocType: Leave Control Panel,Leave blank if considered for all employee types,"Ponechte prázdné, pokud se to považuje za ubytování ve všech typech zaměstnanců"
-DocType: Landed Cost Voucher,Distribute Charges Based On,Distribuovat poplatků na základě
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +253,Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,"Účet {0} musí být typu ""dlouhodobého majetku"", protože položka {1} je majetková položka"
-DocType: HR Settings,HR Settings,Nastavení HR
-apps/frappe/frappe/config/setup.py +130,Printing,Tisk
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +107,Expense Claim is pending approval. Only the Expense Approver can update status.,Úhrada výdajů čeká na schválení. Pouze schalovatel výdajů může aktualizovat stav.
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +99,The day(s) on which you are applying for leave are holiday. You need not apply for leave.,"Den (y), na které žádáte o dovolené jsou dovolenou. Potřebujete nevztahuje na dovolenou."
-sites/assets/js/desk.min.js +684,and,a
-DocType: Leave Block List Allow,Leave Block List Allow,Nechte Block List Povolit
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +49,Sports,Sportovní
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +61,Total Actual,Celkem Aktuální
-DocType: Stock Entry,"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.","Získejte rychlost oceňování a dostupných zásob u zdroje / cílové skladu na uvedeném Datum zveřejnění čase. Pokud se na pokračování položku, stiskněte toto tlačítko po zadání sériového čísla."
-apps/erpnext/erpnext/templates/includes/cart.js +288,Something went wrong.,Něco se pokazilo.
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +574,Unit,Jednotka
-apps/erpnext/erpnext/setup/doctype/backup_manager/backup_dropbox.py +129,Please set Dropbox access keys in your site config,"Prosím, nastavení přístupových klíčů Dropbox ve vašem webu config"
-apps/erpnext/erpnext/stock/get_item_details.py +114,Please specify Company,"Uveďte prosím, firmu"
-,Customer Acquisition and Loyalty,Zákazník Akvizice a loajality
-apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +103,From Time cannot be greater than To Time,"Čas od nemůže být větší, než čas do"
-DocType: Purchase Receipt,Warehouse where you are maintaining stock of rejected items,"Sklad, kde se udržují zásoby odmítnutých položek"
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +406,Your financial year ends on,Váš finanční rok končí
-DocType: POS Setting,Price List,Ceník
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +20,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} je nyní výchozí fiskální rok. Prosím aktualizujte svůj prohlížeč aby se změny projevily.
-apps/erpnext/erpnext/projects/doctype/project/project.js +41,Expense Claims,Nákladové Pohledávky
-DocType: Email Digest,Support,Podpora
-DocType: Authorization Rule,Approving Role,Schvalování roli
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +89,Please specify currency in Company,"Uveďte prosím měnu, ve společnosti"
-DocType: Workstation,Wages per hour,Mzda za hodinu
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +43,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Sklad bilance v dávce {0} se zhorší {1} k bodu {2} ve skladu {3}
-apps/erpnext/erpnext/config/setup.py +53,"Show / Hide features like Serial Nos, POS etc.","Zobrazit / skrýt funkce, jako pořadová čísla, POS atd"
-DocType: Purchase Receipt,LR No,LR No
-apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +34,UOM Conversion factor is required in row {0},UOM Konverzní faktor je nutné v řadě {0}
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +51,Clearance date cannot be before check date in row {0},Datum vůle nemůže být před přihlášením dnem v řadě {0}
-DocType: Salary Slip,Deduction,Dedukce
-DocType: Address Template,Address Template,Šablona adresy
-DocType: Territory,Classification of Customers by region,Rozdělení zákazníků podle krajů
-DocType: Project,% Tasks Completed,% splněných úkolů
-DocType: Project,Gross Margin,Hrubá marže
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +137,Please enter Production Item first,"Prosím, zadejte první výrobní položku"
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +76,disabled user,zakázané uživatelské
-DocType: Opportunity,Quotation,Nabídka
-DocType: Salary Slip,Total Deduction,Celkem Odpočet
-apps/erpnext/erpnext/templates/includes/cart.js +99,Hey! Go ahead and add an address,Hey! Jděte do toho a přidejte adresu
-DocType: Quotation,Maintenance User,Údržba uživatele
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +144,Cost Updated,Náklady Aktualizováno
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +764,Are you sure you want to UNSTOP,"Jste si jisti, že chcete ODZASTAVIT"
-DocType: Employee,Date of Birth,Datum narození
-DocType: Salary Manager,Salary Manager,Plat Správce
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +425,Item {0} has already been returned,Bod {0} již byla vrácena
-DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Fiskální rok ** představuje finanční rok. Veškeré účetní záznamy a další významné transakce jsou sledovány proti ** fiskální rok **.
-DocType: Opportunity,Customer / Lead Address,Zákazník / Lead Address
-DocType: Production Order Operation,Actual Operation Time,Aktuální Provozní doba
-DocType: Authorization Rule,Applicable To (User),Vztahující se na (Uživatel)
-DocType: Purchase Taxes and Charges,Deduct,Odečíst
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +165,Job Description,Popis Práce
-DocType: Purchase Order Item,Qty as per Stock UOM,Množství podle Stock nerozpuštěných
-apps/erpnext/erpnext/utilities/doctype/rename_tool/rename_tool.py +34,Please select a valid csv file with data,Vyberte prosím platný CSV soubor s daty
-DocType: Features Setup,To track items in sales and purchase documents with batch nos<br><b>Preferred Industry: Chemicals etc</b>,Chcete-li sledovat položky v oblasti prodeje a nákupu dokumenty šarže nos <br> <b> Preferovaná Industry: Chemikálie etc </ b>
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +91,Coating,Nátěr
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +121,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Speciální znaky kromě ""-"". """", ""#"", a ""/"" není povoleno v pojmenování řady"
-DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Mějte přehled o prodejních kampaní. Mějte přehled o Leads, citace, prodejní objednávky atd z kampaně, aby zjistily, návratnost investic. "
-DocType: Expense Claim,Approver,Schvalovatel
-,SO Qty,SO Množství
-apps/erpnext/erpnext/accounts/doctype/account/account.py +127,"Stock entries exist against warehouse {0}, hence you cannot re-assign or modify Warehouse","Přírůstky zásob existují proti skladu {0}, a proto není možné přeřadit nebo upravit Warehouse"
-DocType: Appraisal,Calculate Total Score,Vypočítat Celková skóre
-DocType: Salary Slip Deduction,Depends on LWP,Závisí na LWP
-DocType: Supplier Quotation,Manufacturing Manager,Výrobní ředitel
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +201,Serial No {0} is under warranty upto {1},Pořadové číslo {0} je v záruce aľ {1}
-apps/erpnext/erpnext/config/stock.py +69,Split Delivery Note into packages.,Rozdělit dodací list do balíčků.
-apps/erpnext/erpnext/shopping_cart/utils.py +46,Shipments,Zásilky
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +28,Dip molding,Dip lití
-apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +25,Time Log Status must be Submitted.,Time Log Status musí být předloženy.
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +591,Setting Up,Nastavení
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +90,Make Debit Note,Proveďte dluhu
-DocType: Purchase Invoice,In Words (Company Currency),Slovy (měna společnosti)
-DocType: Pricing Rule,Supplier,Dodavatel
-DocType: C-Form,Quarter,Čtvrtletí
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +105,Miscellaneous Expenses,Různé výdaje
-DocType: Global Defaults,Default Company,Výchozí Company
-apps/erpnext/erpnext/controllers/stock_controller.py +165,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Náklady nebo Rozdíl účet je povinné k bodu {0} jako budou mít dopad na celkovou hodnotu zásob
-apps/erpnext/erpnext/controllers/accounts_controller.py +285,"Cannot overbill for Item {0} in row {1} more than {2}. To allow overbilling, please set in Stock Settings","Nelze overbill k bodu {0} v řadě {1} více než {2}. Chcete-li povolit nadfakturace, prosím nastavte na skladě Nastavení"
-DocType: Employee,Bank Name,Název banky
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +38,-Above,-Nad
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +131,User {0} is disabled,Uživatel {0} je zakázána
-DocType: Leave Application,Total Leave Days,Celkový počet dnů dovolené
-DocType: Email Digest,Note: Email will not be sent to disabled users,Poznámka: E-mail se nepodařilo odeslat pro zdravotně postižené uživatele
-apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +36,Select Company...,Vyberte společnost ...
-DocType: Leave Control Panel,Leave blank if considered for all departments,"Ponechte prázdné, pokud se to považuje za všechna oddělení"
-apps/erpnext/erpnext/config/hr.py +95,"Types of employment (permanent, contract, intern etc.).","Druhy pracovního poměru (trvalý, smluv, stážista atd.)"
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +305,{0} is mandatory for Item {1},{0} je povinná k položce {1}
-DocType: Currency Exchange,From Currency,Od Měny
-DocType: DocField,Name,Jméno
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +199,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Prosím, vyberte alokovaná částka, typ faktury a číslo faktury v aspoň jedné řadě"
-apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +61,Last Sales Order Date,Poslední prodejní objednávky Datum
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +90,Sales Order required for Item {0},Prodejní objednávky potřebný k bodu {0}
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Amounts not reflected in system,Částky nejsou zohledněny v systému
-DocType: Purchase Invoice Item,Rate (Company Currency),Cena (Měna Společnosti)
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +40,Others,Ostatní
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +313,Production might not be able to finish by the Expected Delivery Date.,Výroba nemusí být schopen dokončit očekávanou Termín dodání.
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_list.js +19,Set as Stopped,Nastavit jako Zastaveno
-DocType: POS Setting,Taxes and Charges,Daně a poplatky
-DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Produkt nebo služba, která se Nakupuje, Prodává nebo Skladuje."
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +94,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Nelze vybrat druh náboje jako ""On předchozí řady Částka"" nebo ""On předchozí řady Celkem"" pro první řadu"
-apps/frappe/frappe/core/doctype/doctype/boilerplate/controller_list.html +31,Completed,Dokončeno
-DocType: Web Form,Select DocType,Zvolte DocType
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +103,Broaching,Protahování
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +11,Banking,Bankovnictví
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +48,Please click on 'Generate Schedule' to get schedule,"Prosím, klikněte na ""Generovat Schedule"", aby se plán"
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +276,New Cost Center,Nové Nákladové Středisko
-DocType: Bin,Ordered Quantity,Objednané množství
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +395,"e.g. ""Build tools for builders""","např ""Stavět nástroje pro stavitele """
-DocType: Quality Inspection,In Process,V procesu
-DocType: Authorization Rule,Itemwise Discount,Itemwise Sleva
-DocType: Purchase Receipt,Detailed Breakup of the totals,Podrobný rozpadu součty
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +286,{0} against Sales Order {1},{0} proti Prodejní Objednávce {1}
-DocType: Account,Fixed Asset,Základní Jmění
-DocType: Time Log Batch,Total Billing Amount,Celková částka fakturace
-apps/erpnext/erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py +47,Receivable Account,Pohledávky účtu
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +140,No Updates For,Žádné aktualizace pro
-,Stock Balance,Reklamní Balance
-DocType: Expense Claim Detail,Expense Claim Detail,Detail úhrady výdajů
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +259,Time Logs created:,Čas Záznamy vytvořil:
-DocType: Company,If Yearly Budget Exceeded,Pokud Roční rozpočet překročen
-DocType: Item,Weight UOM,Hmotnostní jedn.
-DocType: Employee,Blood Group,Krevní Skupina
-DocType: Purchase Invoice Item,Page Break,Zalomení stránky
-DocType: Production Order Operation,Pending,Až do
-DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,"Uživatelé, kteří si vyhoví žádosti konkrétního zaměstnance volno"
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +50,Office Equipments,Kancelářské Vybavení
-DocType: Purchase Invoice Item,Qty,Množství
-DocType: Fiscal Year,Companies,Společnosti
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +23,Electronics,Elektronika
-DocType: Email Digest,"Balances of Accounts of type ""Bank"" or ""Cash""","Zůstatky na účtech typu ""banka"" nebo ""Cash"""
-DocType: Shipping Rule,"Specify a list of Territories, for which, this Shipping Rule is valid","Zadejte seznam území, pro které tato Shipping pravidlo platí"
-DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Zvýšit Materiál vyžádání při stock dosáhne úrovně re-order
-apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.js +18,From Maintenance Schedule,Z plánu údržby
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +51,Full-time,Na plný úvazek
-DocType: Company,Country Settings,Nastavení Země
-DocType: Employee,Contact Details,Kontaktní údaje
-DocType: C-Form,Received Date,Datum přijetí
-DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Pokud jste vytvořili standardní šablonu v prodeji daní a poplatků šablony, vyberte jednu a klikněte na tlačítko níže."
-DocType: Backup Manager,Upload Backups to Google Drive,Nahrát zálohy na Disk Google
-DocType: Stock Entry,Total Incoming Value,Celková hodnota Příchozí
-apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Nákupní Ceník
-DocType: Offer Letter Term,Offer Term,Nabídka Term
-DocType: Quality Inspection,Quality Manager,Manažer kvality
-DocType: Job Applicant,Job Opening,Job Zahájení
-DocType: Payment Reconciliation,Payment Reconciliation,Platba Odsouhlasení
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +164,Please select Incharge Person's name,"Prosím, vyberte incharge jméno osoby"
-DocType: Delivery Note,Date on which lorry started from your warehouse,"Datum, kdy nákladní automobil začal ze svého skladu"
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +50,Technology,Technologie
-DocType: Purchase Order,Supplier (vendor) name as entered in supplier master,"Dodavatel (prodávající), název, jak je uvedena v dodavatelských master"
-DocType: Offer Letter,Offer Letter,Nabídka Letter
-apps/erpnext/erpnext/config/manufacturing.py +51,Generate Material Requests (MRP) and Production Orders.,Generování materiálu Požadavky (MRP) a výrobní zakázky.
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +68,Total Invoiced Amt,Celkové fakturované Amt
-DocType: Time Log,To Time,Chcete-li čas
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +25,"To add child nodes, explore tree and click on the node under which you want to add more nodes.","Chcete-li přidat podřízené uzly, prozkoumat stromu a klepněte na položku, pod kterou chcete přidat více uzlů."
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +94,Credit To account must be a Payable account,Připsat na účet musí být Splatnost účet
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +236,BOM recursion: {0} cannot be parent or child of {2},BOM rekurze: {0} nemůže být rodič nebo dítě {2}
-DocType: Production Order Operation,Completed Qty,Dokončené Množství
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +135,"For {0}, only debit accounts can be linked against another credit entry","Pro {0}, tak debetní účty mohou být spojeny proti jinému připsání"
-apps/erpnext/erpnext/stock/get_item_details.py +236,Price List {0} is disabled,Ceník {0} je zakázána
-DocType: Manufacturing Settings,Allow Overtime,Povolit Přesčasy
-apps/erpnext/erpnext/controllers/selling_controller.py +247,Sales Order {0} is stopped,Prodejní objednávky {0} je zastaven
-DocType: Email Digest,New Leads,Nové vede
-DocType: Stock Reconciliation Item,Current Valuation Rate,Aktuální ocenění Rate
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +239,"Advance paid against {0} {1} cannot be greater \
+Selling,Prodejnu,
+Salary Information,Vyjednávání o platu,
+Name and Employee ID,Jméno a ID zaměstnance,
+Due Date cannot be before Posting Date,Datum splatnosti nesmí být před odesláním Datum,
+Website Item Group,Website Item Group,
+Duties and Taxes,Odvody a danu,
+Please enter Reference date,"Prosím, zadejte Referenční den"
+Table for Item that will be shown in Web Site,"Tabulka k bodu, který se zobrazí na webových stránkách"
+Supplied Qty,Dodávané Množstvd,
+Material Request Item,Materiál Žádost o bod,
+Tree of Item Groups.,Strom skupiny položek.
+Cannot refer row number greater than or equal to current row number for this Charge type,Nelze odkazovat číslo řádku větší nebo rovnou aktuální číslo řádku pro tento typ Charge,
+Item-wise Purchase History,Item-moudrý Historie nákupe,
+Red,Červene,
+Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Prosím, klikněte na ""Generovat Schedule"", aby přinesla Pořadové číslo přidán k bodu {0}"
+Frozen,Zmraženy,
+Open Production Orders,Otevřené výrobní zakázky,
+Installation Time,Instalace Time,
+Delete all the Transactions for this Company,Odstraňte všechny transakce pro tuto společnost,
+Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row # {0}: Operation {1} není dokončen {2} Množství hotových výrobků ve výrobním procesu objednávky # {3}. Prosím aktualizujte provozní stav přes čas protokoly,
+Investments,Investice,
+Resolution Details,Rozlišení Podrobnosti,
+Change UOM for an Item.,Změna UOM za položku.
+Acceptance Criteria,Kritéria přijetu,
+Attribute Name,Název atributu,
+Item {0} must be Sales or Service Item in {1},Položka {0} musí být prodej či servis položku v {1}
+Show In Website,Show pro webové stránky,
+Group,Skupina,
+Expected Time (in hours),Předpokládaná doba (v hodinách)
+Qty to Order,Množství k objednávce,
+PO No,PO No,
+Gantt chart of all tasks.,Ganttův diagram všech zadaných úkolů.
+For Employee Name,Pro jméno zaměstnance,
+Clear Table,Clear Table,
+Brands,Značky,
+Invoice No,Faktura e,
+From Purchase Order,Z vydané objednávky,
+Please select company first.,Vyberte společnost jako první.
+Costing Rate,Kalkulace Rate,
+Against Journal Entry,Proti položka deníku,
+Resignation Letter Date,Rezignace Letter Datum,
+Pricing Rules are further filtered based on quantity.,Pravidla pro stanovení sazeb jsou dále filtrována na základě množství.
+Not Set,Není nastaveno,
+Date,Datum,
+Repeat Customer Revenue,Repeat Customer Příjmy,
+Sit tight while your system is being setup. This may take a few moments.,"Drž se, když váš systém je nastavení. To může trvat několik okamžiků."
+{0} ({1}) must have role 'Expense Approver',"{0} ({1}), musí mít roli ""Schvalovatel výdajů"""
+Pair,Pár,
+Against Account,Proti účet,
+Actual Date,Skutečné datum,
+Has Batch No,Má číslo šarže,
+Excise Page Number,Spotřební Číslo stránky,
+Personal Details,Osobní data,
+Maintenance Schedules,Plány údržby,
+Embossing,Ražba,
+Quotation Trends,Uvozovky Trendy,
+Item Group not mentioned in item master for item {0},Položka Group není uvedeno v položce mistra na položku {0}
+Debit To account must be a Receivable account,"Debetní Chcete-li v úvahu, musí být pohledávka účet"
+"As Production Order can be made for this item, it must be a stock item.","Jako výrobní objednávce lze provést za tuto položku, musí být skladem."
+Shipping Amount,Přepravní Částka,
+Joining,Spojována,
+Above Value,Výše uvedená hodnota,
+Pending Amount,Čeká Částka,
+Conversion Factor,Konverzní faktor,
+Delivered,Dodáva,
+Setup incoming server for jobs email id. (e.g. jobs@example.com),Nastavení příchozí server pro úlohy e-mailovou id. (Např jobs@example.com)
+The date on which recurring invoice will be stop,"Datum, kdy opakující se faktura bude zastaví"
+Accounts Receivable,Pohledávky,
+Supplier-Wise Sales Analytics,Dodavatel-Wise Prodej Analytics,
+This format is used if country specific format is not found,"Tento formát se používá, když specifický formát země není nalezen"
+Custom,Zvyk,
+Use Multi-Level BOM,Použijte Multi-Level BOM,
+Injection molding,Vstřikovánk,
+Include Reconciled Entries,Zahrnout odsouhlasené zápisy,
+Tree of finanial accounts.,Strom finanial účtů.
+Leave blank if considered for all employee types,"Ponechte prázdné, pokud se to považuje za ubytování ve všech typech zaměstnanců"
+Distribute Charges Based On,Distribuovat poplatků na základ$1,
+Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,"Účet {0} musí být typu ""dlouhodobého majetku"", protože položka {1} je majetková položka"
+HR Settings,Nastavení HR,
+Printing,Tisk,
+Expense Claim is pending approval. Only the Expense Approver can update status.,Úhrada výdajů čeká na schválení. Pouze schalovatel výdajů může aktualizovat stav.
+The day(s) on which you are applying for leave are holiday. You need not apply for leave.,"Den (y), na které žádáte o dovolené jsou dovolenou. Potřebujete nevztahuje na dovolenou."
+and,a,
+Leave Block List Allow,Nechte Block List Povolit,
+Sports,Sportovna,
+Total Actual,Celkem Aktuálna,
+"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.","Získejte rychlost oceňování a dostupných zásob u zdroje / cílové skladu na uvedeném Datum zveřejnění čase. Pokud se na pokračování položku, stiskněte toto tlačítko po zadání sériového čísla."
+Something went wrong.,Něco se pokazilo.
+Unit,Jednotka,
+Please set Dropbox access keys in your site config,"Prosím, nastavení přístupových klíčů Dropbox ve vašem webu config"
+Please specify Company,"Uveďte prosím, firmu"
+Customer Acquisition and Loyalty,Zákazník Akvizice a loajality,
+From Time cannot be greater than To Time,"Čas od nemůže být větší, než čas do"
+Warehouse where you are maintaining stock of rejected items,"Sklad, kde se udržují zásoby odmítnutých položek"
+Your financial year ends on,Váš finanční rok končk,
+Price List,Ceník,
+{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} je nyní výchozí fiskální rok. Prosím aktualizujte svůj prohlížeč aby se změny projevily.
+Expense Claims,Nákladové Pohledávky,
+Support,Podpora,
+Approving Role,Schvalování roli,
+Please specify currency in Company,"Uveďte prosím měnu, ve společnosti"
+Wages per hour,Mzda za hodinu,
+Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Sklad bilance v dávce {0} se zhorší {1} k bodu {2} ve skladu {3}
+"Show / Hide features like Serial Nos, POS etc.","Zobrazit / skrýt funkce, jako pořadová čísla, POS atd"
+LR No,LR No,
+UOM Conversion factor is required in row {0},UOM Konverzní faktor je nutné v řadě {0}
+Clearance date cannot be before check date in row {0},Datum vůle nemůže být před přihlášením dnem v řadě {0}
+Deduction,Dedukce,
+Address Template,Šablona adresy,
+Classification of Customers by region,Rozdělení zákazníků podle kraje,
+% Tasks Completed,% splněných úkole,
+Gross Margin,Hrubá marže,
+Please enter Production Item first,"Prosím, zadejte první výrobní položku"
+disabled user,zakázané uživatelska,
+Quotation,Nabídka,
+Total Deduction,Celkem Odpočet,
+Hey! Go ahead and add an address,Hey! Jděte do toho a přidejte adresu,
+Maintenance User,Údržba uživatele,
+Cost Updated,Náklady Aktualizováno,
+Are you sure you want to UNSTOP,"Jste si jisti, že chcete ODZASTAVIT"
+Date of Birth,Datum narozene,
+Salary Manager,Plat Správce,
+Item {0} has already been returned,Bod {0} již byla vrácena,
+**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Fiskální rok ** představuje finanční rok. Veškeré účetní záznamy a další významné transakce jsou sledovány proti ** fiskální rok **.
+Customer / Lead Address,Zákazník / Lead Address,
+Actual Operation Time,Aktuální Provozní doba,
+Applicable To (User),Vztahující se na (Uživatel)
+Deduct,Odečíst,
+Job Description,Popis Práce,
+Qty as per Stock UOM,Množství podle Stock nerozpuštěných,
+Please select a valid csv file with data,Vyberte prosím platný CSV soubor s daty,
+To track items in sales and purchase documents with batch nos<br><b>Preferred Industry: Chemicals etc</b>,Chcete-li sledovat položky v oblasti prodeje a nákupu dokumenty šarže nos <br> <b> Preferovaná Industry: Chemikálie etc </ b>
+Coating,Nátěr,
+"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Speciální znaky kromě ""-"". """", ""#"", a ""/"" není povoleno v pojmenování řady"
+"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Mějte přehled o prodejních kampaní. Mějte přehled o Leads, citace, prodejní objednávky atd z kampaně, aby zjistily, návratnost investic. "
+Approver,Schvalovatel,
+SO Qty,SO Množstvl,
+"Stock entries exist against warehouse {0}, hence you cannot re-assign or modify Warehouse","Přírůstky zásob existují proti skladu {0}, a proto není možné přeřadit nebo upravit Warehouse"
+Calculate Total Score,Vypočítat Celková skóre,
+Depends on LWP,Závisí na LWP,
+Manufacturing Manager,Výrobní ředitel,
+Serial No {0} is under warranty upto {1},Pořadové číslo {0} je v záruce aľ {1}
+Split Delivery Note into packages.,Rozdělit dodací list do balíčků.
+Shipments,Zásilky,
+Dip molding,Dip lity,
+Time Log Status must be Submitted.,Time Log Status musí být předloženy.
+Setting Up,Nastavenu,
+Make Debit Note,Proveďte dluhu,
+In Words (Company Currency),Slovy (měna společnosti)
+Supplier,Dodavatel,
+Quarter,Čtvrtletl,
+Miscellaneous Expenses,Různé výdaje,
+Default Company,Výchozí Company,
+Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Náklady nebo Rozdíl účet je povinné k bodu {0} jako budou mít dopad na celkovou hodnotu zásob,
+"Cannot overbill for Item {0} in row {1} more than {2}. To allow overbilling, please set in Stock Settings","Nelze overbill k bodu {0} v řadě {1} více než {2}. Chcete-li povolit nadfakturace, prosím nastavte na skladě Nastavení"
+Bank Name,Název banky,
+-Above,-Nad,
+User {0} is disabled,Uživatel {0} je zakázána,
+Total Leave Days,Celkový počet dnů dovoleny,
+Note: Email will not be sent to disabled users,Poznámka: E-mail se nepodařilo odeslat pro zdravotně postižené uživatele,
+Select Company...,Vyberte společnost ...
+Leave blank if considered for all departments,"Ponechte prázdné, pokud se to považuje za všechna oddělení"
+"Types of employment (permanent, contract, intern etc.).","Druhy pracovního poměru (trvalý, smluv, stážista atd.)"
+{0} is mandatory for Item {1},{0} je povinná k položce {1}
+From Currency,Od Měny,
+Name,Jméno,
+"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Prosím, vyberte alokovaná částka, typ faktury a číslo faktury v aspoň jedné řadě"
+Last Sales Order Date,Poslední prodejní objednávky Datum,
+Sales Order required for Item {0},Prodejní objednávky potřebný k bodu {0}
+Amounts not reflected in system,Částky nejsou zohledněny v systému,
+Rate (Company Currency),Cena (Měna Společnosti)
+Others,Ostatn$1,
+Production might not be able to finish by the Expected Delivery Date.,Výroba nemusí být schopen dokončit očekávanou Termín dodání.
+Set as Stopped,Nastavit jako Zastaveno,
+Taxes and Charges,Daně a poplatky,
+"A Product or a Service that is bought, sold or kept in stock.","Produkt nebo služba, která se Nakupuje, Prodává nebo Skladuje."
+Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Nelze vybrat druh náboje jako ""On předchozí řady Částka"" nebo ""On předchozí řady Celkem"" pro první řadu"
+Completed,Dokončeno,
+Select DocType,Zvolte DocType,
+Broaching,Protahováno,
+Banking,Bankovnictvo,
+Please click on 'Generate Schedule' to get schedule,"Prosím, klikněte na ""Generovat Schedule"", aby se plán"
+New Cost Center,Nové Nákladové Středisko,
+Ordered Quantity,Objednané množstvo,
+"e.g. ""Build tools for builders""","např ""Stavět nástroje pro stavitele """
+In Process,V procesu,
+Itemwise Discount,Itemwise Sleva,
+Detailed Breakup of the totals,Podrobný rozpadu součty,
+{0} against Sales Order {1},{0} proti Prodejní Objednávce {1}
+Fixed Asset,Základní Jměne,
+Total Billing Amount,Celková částka fakturace,
+Receivable Account,Pohledávky účtu,
+No Updates For,Žádné aktualizace pro,
+Stock Balance,Reklamní Balance,
+Expense Claim Detail,Detail úhrady výdaje,
+Time Logs created:,Čas Záznamy vytvořil:
+If Yearly Budget Exceeded,Pokud Roční rozpočet překročen,
+Weight UOM,Hmotnostní jedn.
+Blood Group,Krevní Skupina,
+Page Break,Zalomení stránky,
+Pending,Až do,
+Users who can approve a specific employee's leave applications,"Uživatelé, kteří si vyhoví žádosti konkrétního zaměstnance volno"
+Office Equipments,Kancelářské Vybaveni,
+Qty,Množstvi,
+Companies,Společnosti,
+Electronics,Elektronika,
+"Balances of Accounts of type ""Bank"" or ""Cash""","Zůstatky na účtech typu ""banka"" nebo ""Cash"""
+"Specify a list of Territories, for which, this Shipping Rule is valid","Zadejte seznam území, pro které tato Shipping pravidlo platí"
+Raise Material Request when stock reaches re-order level,Zvýšit Materiál vyžádání při stock dosáhne úrovně re-order,
+From Maintenance Schedule,Z plánu údržby,
+Full-time,Na plný úvazek,
+Country Settings,Nastavení Zemr,
+Contact Details,Kontaktní údaje,
+Received Date,Datum přijetr,
+"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Pokud jste vytvořili standardní šablonu v prodeji daní a poplatků šablony, vyberte jednu a klikněte na tlačítko níže."
+Upload Backups to Google Drive,Nahrát zálohy na Disk Google,
+Total Incoming Value,Celková hodnota Příchoze,
+Purchase Price List,Nákupní Ceník,
+Offer Term,Nabídka Term,
+Quality Manager,Manažer kvality,
+Job Opening,Job Zahájene,
+Payment Reconciliation,Platba Odsouhlasene,
+Please select Incharge Person's name,"Prosím, vyberte incharge jméno osoby"
+Date on which lorry started from your warehouse,"Datum, kdy nákladní automobil začal ze svého skladu"
+Technology,Technologie,
+Supplier (vendor) name as entered in supplier master,"Dodavatel (prodávající), název, jak je uvedena v dodavatelských master"
+Offer Letter,Nabídka Letter,
+Generate Material Requests (MRP) and Production Orders.,Generování materiálu Požadavky (MRP) a výrobní zakázky.
+Total Invoiced Amt,Celkové fakturované Amt,
+To Time,Chcete-li čas,
+"To add child nodes, explore tree and click on the node under which you want to add more nodes.","Chcete-li přidat podřízené uzly, prozkoumat stromu a klepněte na položku, pod kterou chcete přidat více uzlů."
+Credit To account must be a Payable account,Připsat na účet musí být Splatnost účet,
+BOM recursion: {0} cannot be parent or child of {2},BOM rekurze: {0} nemůže být rodič nebo dítě {2}
+Completed Qty,Dokončené Množstv$1,
+"For {0}, only debit accounts can be linked against another credit entry","Pro {0}, tak debetní účty mohou být spojeny proti jinému připsání"
+Price List {0} is disabled,Ceník {0} je zakázána,
+Allow Overtime,Povolit Přesčasy,
+Sales Order {0} is stopped,Prodejní objednávky {0} je zastaven,
+New Leads,Nové vede,
+Current Valuation Rate,Aktuální ocenění Rate,
+"Advance paid against {0} {1} cannot be greater \
 					than Grand Total {2}","Vyplacena záloha na {0} {1} nemůže být větší \
  než Celkový součet {2}"
-DocType: Opportunity,Lost Reason,Ztracené Důvod
-apps/erpnext/erpnext/config/accounts.py +68,Create Payment Entries against Orders or Invoices.,Vytvořte Platební záznamy proti objednávky nebo faktury.
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +140,Welding,Svařování
-apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +18,New Stock UOM is required,Je zapotřebí nové Reklamní UOM
-DocType: Quality Inspection,Sample Size,Velikost vzorku
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +418,All items have already been invoiced,Všechny položky již byly fakturovány
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +47,Please specify a valid 'From Case No.',"Uveďte prosím platný ""Od věci č '"
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +280,Further cost centers can be made under Groups but entries can be made against non-Groups,"Další nákladová střediska mohou být vyrobeny v rámci skupiny, ale položky mohou být provedeny proti non-skupin"
-DocType: Project,External,Externí
-DocType: Features Setup,Item Serial Nos,Položka sériových čísel
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_list.js +8,Not Received,Neobdržel
-DocType: Branch,Branch,Větev
-DocType: Sales Invoice,Customer (Receivable) Account,Customer (pohledávka) Account
-DocType: Bin,Actual Quantity,Skutečné Množství
-DocType: Shipping Rule,example: Next Day Shipping,Příklad: Next Day Shipping
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +198,Serial No {0} not found,Pořadové číslo {0} nebyl nalezen
-DocType: Shopping Cart Settings,Price Lists,Ceníky
-DocType: Purchase Invoice,Considered as Opening Balance,Považován za počáteční zůstatek
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +513,Your Customers,Vaši Zákazníci
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +26,Compression molding,Lisování
-DocType: Leave Block List Date,Block Date,Block Datum
-DocType: Sales Order,Not Delivered,Ne vyhlášeno
-,Bank Clearance Summary,Souhrn bankovního zúčtování
-apps/erpnext/erpnext/config/setup.py +75,"Create and manage daily, weekly and monthly email digests.","Vytvářet a spravovat denní, týdenní a měsíční e-mailové digest."
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +46,Item Code > Item Group > Brand,Kód položky> Položka Group> Brand
-DocType: Appraisal Goal,Appraisal Goal,Posouzení Goal
-DocType: Event,Friday,Pátek
-DocType: Time Log,Costing Amount,Kalkulace Částka
-DocType: Salary Manager,Submit Salary Slip,Odeslat výplatní pásce
-DocType: Salary Structure,Monthly Earning & Deduction,Měsíčního výdělku a dedukce
-apps/erpnext/erpnext/controllers/selling_controller.py +162,Maxiumm discount for Item {0} is {1}%,Maxiumm sleva na položky {0} {1}%
-DocType: Supplier,Address & Contacts,Adresa a kontakty
-DocType: SMS Log,Sender Name,Jméno odesílatele
-DocType: Page,Title,Titulek
-sites/assets/js/list.min.js +92,Customize,Přizpůsobit
-DocType: POS Setting,[Select],[Vybrat]
-apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +28,Make Sales Invoice,Proveďte prodejní faktuře
-DocType: Company,For Reference Only.,Pouze orientační.
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +45,Invalid {0}: {1},Neplatný {0}: {1}
-DocType: Sales Invoice Advance,Advance Amount,Záloha ve výši
-DocType: Manufacturing Settings,Capacity Planning,Plánování kapacit
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +49,'From Date' is required,"""Datum od"" je povinné"
-DocType: Journal Entry,Reference Number,Referenční číslo
-DocType: Employee,Employment Details,Informace o zaměstnání
-DocType: Employee,New Workplace,Nové pracoviště
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Nastavit jako Zavřeno
-apps/erpnext/erpnext/stock/get_item_details.py +104,No Item with Barcode {0},No Položka s čárovým kódem {0}
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,Case No. cannot be 0,Případ č nemůže být 0
-DocType: Features Setup,If you have Sales Team and Sale Partners (Channel Partners)  they can be tagged and maintain their contribution in the sales activity,"Máte-li prodejní tým a prodej Partners (obchodních partnerů), které mohou být označeny a udržovat svůj příspěvek v prodejní činnosti"
-DocType: Item,Show a slideshow at the top of the page,Ukazují prezentaci v horní části stránky
-apps/erpnext/erpnext/setup/doctype/company/company.py +71,Stores,Obchody
-DocType: Time Log,Projects Manager,Správce projektů
-DocType: Serial No,Delivery Time,Dodací lhůta
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,Stárnutí dle
-DocType: Item,End of Life,Konec životnosti
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +41,Travel,Cestování
-DocType: Leave Block List,Allow Users,Povolit uživatele
-apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +199,Operation is Mandatory,Provoz je Povinné
-DocType: Purchase Order,Recurring,Opakující se
-DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Sledovat samostatné výnosy a náklady pro vertikál produktu nebo divizí.
-DocType: Rename Tool,Rename Tool,Přejmenování
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +11,Update Cost,Aktualizace Cost
-DocType: Item Reorder,Item Reorder,Položka Reorder
-DocType: Address,Check to make primary address,Zaškrtněte pro vytvoření primární adresy
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +507,Transfer Material,Přenos materiálu
-DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Zadejte operací, provozní náklady a dávají jedinečnou operaci ne své operace."
-DocType: Purchase Invoice,Price List Currency,Ceník Měna
-DocType: Naming Series,User must always select,Uživatel musí vždy vybrat
-DocType: Stock Settings,Allow Negative Stock,Povolit Negativní Sklad
-DocType: Installation Note,Installation Note,Poznámka k instalaci
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +491,Add Taxes,Přidejte daně
-,Financial Analytics,Finanční Analýza
-DocType: Quality Inspection,Verified By,Verified By
-DocType: Address,Subsidiary,Dceřiný
-apps/erpnext/erpnext/setup/doctype/company/company.py +37,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Nelze změnit výchozí měně společnosti, protože tam jsou stávající transakce. Transakce musí být zrušena, aby změnit výchozí měnu."
-DocType: Quality Inspection,Purchase Receipt No,Číslo příjmky
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,Earnest Money
-DocType: Salary Manager,Create Salary Slip,Vytvořit výplatní pásce
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +44,Expected balance as per bank,Očekávaný zůstatek podle banky
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +114,Buffing,Leštění
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +158,Source of Funds (Liabilities),Zdrojem finančních prostředků (závazků)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +383,Quantity in row {0} ({1}) must be same as manufactured quantity {2},"Množství v řadě {0} ({1}), musí být stejné jako množství vyrobené {2}"
-DocType: Appraisal,Employee,Zaměstnanec
-apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +10,Import Email From,Importovat e-maily z
-DocType: Features Setup,After Sale Installations,Po prodeji instalací
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +233,{0} {1} is fully billed,{0} {1} je plně fakturováno
-DocType: Workstation Working Hour,End Time,End Time
-apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Standardní smluvní podmínky pro prodej nebo koupi.
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +79,Group by Voucher,Seskupit podle Poukazu
-apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Povinné On
-DocType: Sales Invoice,Mass Mailing,Hromadné emaily
-DocType: Page,Standard,Standard
-DocType: Rename Tool,File to Rename,Soubor přejmenovat
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +175,Purchse Order number required for Item {0},Purchse Objednací číslo potřebný k bodu {0}
-apps/erpnext/erpnext/controllers/buying_controller.py +246,Specified BOM {0} does not exist for Item {1},Stanovená BOM {0} neexistuje k bodu {1}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +183,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Plán údržby {0} musí být zrušena před zrušením této prodejní objednávky
-DocType: Email Digest,Payments Received,Přijaté platby
-DocType: Cost Center,"Define Budget for this Cost Center. To set budget action, see <a href=""#!List/Company"">Company Master</a>","Definovat rozpočtu na tento nákladového střediska. Chcete-li nastavit rozpočtu akce, viz <a href = ""#!List / Company ""> Společnost Mistr </a>"
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +138,Size,Velikost
-DocType: Notification Control,Expense Claim Approved,Uhrazení výdajů schváleno
-DocType: Email Digest,Calendar Events,Kalendář akcí
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +108,Pharmaceutical,Farmaceutické
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Náklady na zakoupené zboží
-DocType: Selling Settings,Sales Order Required,Prodejní objednávky Povinné
-apps/erpnext/erpnext/crm/doctype/lead/lead.js +30,Create Customer,Vytvořit zákazníka
-DocType: Purchase Invoice,Credit To,Kredit:
-DocType: Employee Education,Post Graduate,Postgraduální
-DocType: Backup Manager,"Note: Backups and files are not deleted from Dropbox, you will have to delete them manually.","Poznámka: Zálohy a soubory nejsou odstraněny z Dropbox, budete muset odstranit ručně."
-DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Plán údržby Detail
-DocType: Quality Inspection Reading,Reading 9,Čtení 9
-DocType: Buying Settings,Buying Settings,Nákup Nastavení
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +121,Mass finishing,Mass dokončovací
-DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM Ne pro hotový dobré položce
-DocType: Upload Attendance,Attendance To Date,Účast na data
-apps/erpnext/erpnext/config/selling.py +153,Setup incoming server for sales email id. (e.g. sales@example.com),Nastavení příchozí server pro prodej e-mailovou id. (Např sales@example.com)
-DocType: Warranty Claim,Raised By,Vznesené
-DocType: Payment Tool,Payment Account,Platební účet
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +725,Please specify Company to proceed,Uveďte prosím společnost pokračovat
-apps/erpnext/erpnext/setup/doctype/backup_manager/backup_manager.js +14,Google Drive,Google Drive
-sites/assets/js/list.min.js +22,Draft,Návrh
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +45,Compensatory Off,Vyrovnávací Off
-DocType: Quality Inspection Reading,Accepted,Přijato
-DocType: User,Female,Žena
-apps/erpnext/erpnext/setup/doctype/company/company.js +19,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,"Ujistěte se, že opravdu chcete vymazat všechny transakce pro tuto společnost. Vaše kmenová data zůstanou, jak to je. Tuto akci nelze vrátit zpět."
-DocType: Print Settings,Modern,Moderní
-DocType: Communication,Replied,Odpovězeno
-DocType: Payment Tool,Total Payment Amount,Celková Částka platby
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +136,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},"{0} ({1}) nemůže být větší, než Plánované Množství ({2}), ve Výrobní Objednávce {3}"
-DocType: Shipping Rule,Shipping Rule Label,Přepravní Pravidlo Label
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +212,Raw Materials cannot be blank.,Suroviny nemůže být prázdný.
-DocType: Newsletter,Test,Test
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +84,You can not change rate if BOM mentioned agianst any item,"Nemůžete změnit sazbu, kdyby BOM zmínil agianst libovolné položky"
-DocType: Employee,Previous Work Experience,Předchozí pracovní zkušenosti
-DocType: Stock Entry,For Quantity,Pro Množství
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +162,Please enter Planned Qty for Item {0} at row {1},"Prosím, zadejte Plánované Množství k bodu {0} na řádku {1}"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +218,{0} {1} is not submitted,{0} {1} není odesláno
-apps/erpnext/erpnext/config/stock.py +13,Requests for items.,Žádosti o položky.
-DocType: Production Planning Tool,Separate production order will be created for each finished good item.,Samostatná výroba objednávka bude vytvořena pro každého hotového dobrou položku.
-DocType: Email Digest,New Communications,Nová komunikace
-DocType: Purchase Invoice,Terms and Conditions1,Podmínky a podmínek1
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard_page.html +18,Complete Setup,Kompletní nastavení
-DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Účetní záznam zmrazeny až do tohoto data, nikdo nemůže dělat / upravit položku kromě role uvedeno níže."
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.js +124,Please save the document before generating maintenance schedule,"Prosím, uložit dokument před generováním plán údržby"
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Stav projektu
-DocType: UOM,Check this to disallow fractions. (for Nos),"Zkontrolujte, zda to zakázat frakce. (U č)"
-apps/erpnext/erpnext/config/crm.py +86,Newsletter Mailing List,Newsletter adresář
-DocType: Delivery Note,Transporter Name,Přepravce Název
-DocType: Contact,Enter department to which this Contact belongs,"Zadejte útvar, který tento kontaktní patří"
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +56,Total Absent,Celkem Absent
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +716,Item or Warehouse for row {0} does not match Material Request,Položka nebo Warehouse na řádku {0} neodpovídá Materiál Poptávka
-apps/erpnext/erpnext/config/stock.py +109,Unit of Measure,Měrná jednotka
-DocType: Fiscal Year,Year End Date,Datum Konce Roku
-DocType: Task Depends On,Task Depends On,Úkol je závislá na
-DocType: Lead,Opportunity,Příležitost
-DocType: Salary Structure Earning,Salary Structure Earning,Plat Struktura Zisk
-,Completed Production Orders,Dokončené Výrobní zakázky
-DocType: Operation,Default Workstation,Výchozí Workstation
-DocType: Email Digest,Inventory & Support,Zásoby a podpora
-DocType: Notification Control,Expense Claim Approved Message,Zpráva o schválení úhrady výdajů
-DocType: Email Digest,How frequently?,Jak často?
-DocType: Purchase Receipt,Get Current Stock,Získejte aktuální stav
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +619,Make Installation Note,Proveďte Instalace Poznámka
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +208,Maintenance start date can not be before delivery date for Serial No {0},Datum zahájení údržby nemůže být před datem dodání pro pořadové číslo {0}
-DocType: Production Order,Actual End Date,Skutečné datum ukončení
-DocType: Authorization Rule,Applicable To (Role),Vztahující se na (Role)
-DocType: Stock Entry,Purpose,Účel
-DocType: Item,Will also apply for variants unless overrridden,"Bude platit i pro varianty, pokud nebude přepsáno"
-DocType: Purchase Invoice,Advances,Zálohy
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,Schválení Uživatel nemůže být stejná jako uživatel pravidlo se vztahuje na
-DocType: SMS Log,No of Requested SMS,Počet žádaným SMS
-DocType: Campaign,Campaign-.####,Kampaň-.####
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +485,Make Invoice,Proveďte faktury
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +54,Piercing,Pronikavý
-DocType: Customer,Your Customer's TAX registration numbers (if applicable) or any general information,DIČ Vašeho zákazníka (pokud má) nebo jakékoli obecné informace
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +113,Contract End Date must be greater than Date of Joining,Smlouva Datum ukončení musí být větší než Datum spojování
-DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,"Distributor / dealer / jednatel / partner / prodejce, který prodává produkty společnosti za provizi."
-DocType: Customer Group,Has Child Node,Má děti Node
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299,{0} against Purchase Order {1},{0} proti Nákupní Objednávce {1}
-DocType: SMS Settings,"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)","Zadejte statické parametry url zde (Např odesílatel = ERPNext, username = ERPNext, password. = 1234 atd.),"
-apps/erpnext/erpnext/setup/page/setup_wizard/default_website.py +26,This is an example website auto-generated from ERPNext,To je příklad webové stránky automaticky generované z ERPNext
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +37,Ageing Range 1,Stárnutí Rozsah 1
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +109,Photochemical machining,Fotochemický obrábění
-DocType: Purchase Taxes and Charges Template,"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
+Lost Reason,Ztracené Důvod,
+Create Payment Entries against Orders or Invoices.,Vytvořte Platební záznamy proti objednávky nebo faktury.
+Welding,SvařovánM,
+New Stock UOM is required,Je zapotřebí nové Reklamní UOM,
+Sample Size,Velikost vzorku,
+All items have already been invoiced,Všechny položky již byly fakturovány,
+Please specify a valid 'From Case No.',"Uveďte prosím platný ""Od věci č '"
+Further cost centers can be made under Groups but entries can be made against non-Groups,"Další nákladová střediska mohou být vyrobeny v rámci skupiny, ale položky mohou být provedeny proti non-skupin"
+External,Externl,
+Item Serial Nos,Položka sériových čísel,
+Not Received,Neobdržel,
+Branch,Větev,
+Customer (Receivable) Account,Customer (pohledávka) Account,
+Actual Quantity,Skutečné Množstvl,
+example: Next Day Shipping,Příklad: Next Day Shipping,
+Serial No {0} not found,Pořadové číslo {0} nebyl nalezen,
+Price Lists,Ceníky,
+Considered as Opening Balance,Považován za počáteční zůstatek,
+Your Customers,Vaši Zákazníci,
+Compression molding,Lisovánl,
+Block Date,Block Datum,
+Not Delivered,Ne vyhlášeno,
+Bank Clearance Summary,Souhrn bankovního zúčtovánl,
+"Create and manage daily, weekly and monthly email digests.","Vytvářet a spravovat denní, týdenní a měsíční e-mailové digest."
+Item Code > Item Group > Brand,Kód položky> Položka Group> Brand,
+Appraisal Goal,Posouzení Goal,
+Friday,Pátek,
+Costing Amount,Kalkulace Částka,
+Submit Salary Slip,Odeslat výplatní pásce,
+Monthly Earning & Deduction,Měsíčního výdělku a dedukce,
+Maxiumm discount for Item {0} is {1}%,Maxiumm sleva na položky {0} {1}%
+Address & Contacts,Adresa a kontakty,
+Sender Name,Jméno odesílatele,
+Title,Titulek,
+Customize,Přizpůsobit,
+[Select],[Vybrat]
+Make Sales Invoice,Proveďte prodejní faktuře,
+For Reference Only.,Pouze orientační.
+Invalid {0}: {1},Neplatný {0}: {1}
+Advance Amount,Záloha ve výši,
+Capacity Planning,Plánování kapacit,
+'From Date' is required,"""Datum od"" je povinné"
+Reference Number,Referenční číslo,
+Employment Details,Informace o zaměstnáno,
+New Workplace,Nové pracovišto,
+Set as Closed,Nastavit jako Zavřeno,
+No Item with Barcode {0},No Položka s čárovým kódem {0}
+Case No. cannot be 0,Případ č nemůže být 0,
+If you have Sales Team and Sale Partners (Channel Partners)  they can be tagged and maintain their contribution in the sales activity,"Máte-li prodejní tým a prodej Partners (obchodních partnerů), které mohou být označeny a udržovat svůj příspěvek v prodejní činnosti"
+Show a slideshow at the top of the page,Ukazují prezentaci v horní části stránky,
+Stores,Obchody,
+Projects Manager,Správce projekty,
+Delivery Time,Dodací lhůta,
+Ageing Based On,Stárnutí dle,
+End of Life,Konec životnosti,
+Travel,Cestovány,
+Allow Users,Povolit uživatele,
+Operation is Mandatory,Provoz je Povinny,
+Recurring,Opakující se,
+Track separate Income and Expense for product verticals or divisions.,Sledovat samostatné výnosy a náklady pro vertikál produktu nebo divizí.
+Rename Tool,Přejmenovánt,
+Update Cost,Aktualizace Cost,
+Item Reorder,Položka Reorder,
+Check to make primary address,Zaškrtněte pro vytvoření primární adresy,
+Transfer Material,Přenos materiálu,
+"Specify the operations, operating cost and give a unique Operation no to your operations.","Zadejte operací, provozní náklady a dávají jedinečnou operaci ne své operace."
+Price List Currency,Ceník Měna,
+User must always select,Uživatel musí vždy vybrat,
+Allow Negative Stock,Povolit Negativní Sklad,
+Installation Note,Poznámka k instalaci,
+Add Taxes,Přidejte dana,
+Financial Analytics,Finanční Analýza,
+Verified By,Verified By,
+Subsidiary,Dceřina,
+"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Nelze změnit výchozí měně společnosti, protože tam jsou stávající transakce. Transakce musí být zrušena, aby změnit výchozí měnu."
+Purchase Receipt No,Číslo příjmky,
+Earnest Money,Earnest Money,
+Create Salary Slip,Vytvořit výplatní pásce,
+Expected balance as per bank,Očekávaný zůstatek podle banky,
+Buffing,Leštěny,
+Source of Funds (Liabilities),Zdrojem finančních prostředků (závazků)
+Quantity in row {0} ({1}) must be same as manufactured quantity {2},"Množství v řadě {0} ({1}), musí být stejné jako množství vyrobené {2}"
+Employee,Zaměstnanec,
+Import Email From,Importovat e-maily z,
+After Sale Installations,Po prodeji instalacc,
+{0} {1} is fully billed,{0} {1} je plně fakturováno,
+End Time,End Time,
+Standard contract terms for Sales or Purchase.,Standardní smluvní podmínky pro prodej nebo koupi.
+Group by Voucher,Seskupit podle Poukazu,
+Required On,Povinné On,
+Mass Mailing,Hromadné emaily,
+Standard,Standard,
+File to Rename,Soubor přejmenovat,
+Purchse Order number required for Item {0},Purchse Objednací číslo potřebný k bodu {0}
+Specified BOM {0} does not exist for Item {1},Stanovená BOM {0} neexistuje k bodu {1}
+Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Plán údržby {0} musí být zrušena před zrušením této prodejní objednávky,
+Payments Received,Přijaté platby,
+"Define Budget for this Cost Center. To set budget action, see <a href=""#!List/Company"">Company Master</a>","Definovat rozpočtu na tento nákladového střediska. Chcete-li nastavit rozpočtu akce, viz <a href = ""#!List / Company ""> Společnost Mistr </a>"
+Size,Velikost,
+Expense Claim Approved,Uhrazení výdajů schváleno,
+Calendar Events,Kalendář akct,
+Pharmaceutical,Farmaceutickt,
+Cost of Purchased Items,Náklady na zakoupené zbožt,
+Sales Order Required,Prodejní objednávky Povinnt,
+Create Customer,Vytvořit zákazníka,
+Credit To,Kredit:
+Post Graduate,Postgraduáln$1,
+"Note: Backups and files are not deleted from Dropbox, you will have to delete them manually.","Poznámka: Zálohy a soubory nejsou odstraněny z Dropbox, budete muset odstranit ručně."
+Maintenance Schedule Detail,Plán údržby Detail,
+Reading 9,Čtení 9,
+Buying Settings,Nákup Nastavenl,
+Mass finishing,Mass dokončovacl,
+BOM No. for a Finished Good Item,BOM Ne pro hotový dobré položce,
+Attendance To Date,Účast na data,
+Setup incoming server for sales email id. (e.g. sales@example.com),Nastavení příchozí server pro prodej e-mailovou id. (Např sales@example.com)
+Raised By,Vznesent,
+Payment Account,Platební účet,
+Please specify Company to proceed,Uveďte prosím společnost pokračovat,
+Google Drive,Google Drive,
+Draft,Návrh,
+Compensatory Off,Vyrovnávací Off,
+Accepted,Přijato,
+Female,Žena,
+Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,"Ujistěte se, že opravdu chcete vymazat všechny transakce pro tuto společnost. Vaše kmenová data zůstanou, jak to je. Tuto akci nelze vrátit zpět."
+Modern,Moderno,
+Replied,Odpovězeno,
+Total Payment Amount,Celková Částka platby,
+{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},"{0} ({1}) nemůže být větší, než Plánované Množství ({2}), ve Výrobní Objednávce {3}"
+Shipping Rule Label,Přepravní Pravidlo Label,
+Raw Materials cannot be blank.,Suroviny nemůže být prázdný.
+Test,Test,
+You can not change rate if BOM mentioned agianst any item,"Nemůžete změnit sazbu, kdyby BOM zmínil agianst libovolné položky"
+Previous Work Experience,Předchozí pracovní zkušenosti,
+For Quantity,Pro Množstvi,
+Please enter Planned Qty for Item {0} at row {1},"Prosím, zadejte Plánované Množství k bodu {0} na řádku {1}"
+{0} {1} is not submitted,{0} {1} není odesláno,
+Requests for items.,Žádosti o položky.
+Separate production order will be created for each finished good item.,Samostatná výroba objednávka bude vytvořena pro každého hotového dobrou položku.
+New Communications,Nová komunikace,
+Terms and Conditions1,Podmínky a podmínek1,
+Complete Setup,Kompletní nastavene,
+"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Účetní záznam zmrazeny až do tohoto data, nikdo nemůže dělat / upravit položku kromě role uvedeno níže."
+Please save the document before generating maintenance schedule,"Prosím, uložit dokument před generováním plán údržby"
+Project Status,Stav projektu,
+Check this to disallow fractions. (for Nos),"Zkontrolujte, zda to zakázat frakce. (U č)"
+Newsletter Mailing List,Newsletter adresáv,
+Transporter Name,Přepravce Název,
+Enter department to which this Contact belongs,"Zadejte útvar, který tento kontaktní patří"
+Total Absent,Celkem Absent,
+Item or Warehouse for row {0} does not match Material Request,Položka nebo Warehouse na řádku {0} neodpovídá Materiál Poptávka,
+Unit of Measure,Měrná jednotka,
+Year End Date,Datum Konce Roku,
+Task Depends On,Úkol je závislá na,
+Opportunity,Příležitost,
+Salary Structure Earning,Plat Struktura Zisk,
+Completed Production Orders,Dokončené Výrobní zakázky,
+Default Workstation,Výchozí Workstation,
+Inventory & Support,Zásoby a podpora,
+Expense Claim Approved Message,Zpráva o schválení úhrady výdajt,
+How frequently?,Jak často?
+Get Current Stock,Získejte aktuální stav,
+Make Installation Note,Proveďte Instalace Poznámka,
+Maintenance start date can not be before delivery date for Serial No {0},Datum zahájení údržby nemůže být před datem dodání pro pořadové číslo {0}
+Actual End Date,Skutečné datum ukončen$1,
+Applicable To (Role),Vztahující se na (Role)
+Purpose,Účel,
+Will also apply for variants unless overrridden,"Bude platit i pro varianty, pokud nebude přepsáno"
+Advances,Zálohy,
+Approving User cannot be same as user the rule is Applicable To,Schválení Uživatel nemůže být stejná jako uživatel pravidlo se vztahuje na,
+No of Requested SMS,Počet žádaným SMS,
+Campaign-.####,Kampaň-.####
+Make Invoice,Proveďte faktury,
+Piercing,Pronikavy,
+Your Customer's TAX registration numbers (if applicable) or any general information,DIČ Vašeho zákazníka (pokud má) nebo jakékoli obecné informace,
+Contract End Date must be greater than Date of Joining,Smlouva Datum ukončení musí být větší než Datum spojovány,
+A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,"Distributor / dealer / jednatel / partner / prodejce, který prodává produkty společnosti za provizi."
+Has Child Node,Má děti Node,
+{0} against Purchase Order {1},{0} proti Nákupní Objednávce {1}
+"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)","Zadejte statické parametry url zde (Např odesílatel = ERPNext, username = ERPNext, password. = 1234 atd.),"
+This is an example website auto-generated from ERPNext,To je příklad webové stránky automaticky generované z ERPNext,
+Ageing Range 1,Stárnutí Rozsah 1,
+Photochemical machining,Fotochemický obráběnt,
+"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
 
-#### Note
+#### Note,
 
 The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.
 
-#### Description of Columns
+#### Description of Columns,
 
 1. Calculation Type: 
     - This can be on **Net Total** (that is the sum of basic amount).
     - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
     - **Actual** (as mentioned).
-2. Account Head: The Account ledger under which this tax will be booked
+2. Account Head: The Account ledger under which this tax will be booked,
 3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
 4. Description: Description of the tax (that will be printed in invoices / quotes).
 5. Rate: Tax rate.
@@ -2048,162 +2048,162 @@
  8. Zadejte Row: Je-li na základě ""předchozí řady Total"" můžete zvolit číslo řádku, která bude přijata jako základ pro tento výpočet (výchozí je předchozí řádek).
  9. Zvažte daň či poplatek za: V této části můžete nastavit, zda daň / poplatek je pouze pro ocenění (není součástí celkem), nebo pouze pro celkem (není přidanou hodnotu do položky), nebo pro obojí.
  10. Přidat nebo odečítat: Ať už chcete přidat nebo odečíst daň."
-DocType: Note,Note,Poznámka
-DocType: Email Digest,New Material Requests,Nové žádosti Materiál
-DocType: Purchase Receipt Item,Recd Quantity,Recd Množství
-DocType: Email Account,Email Ids,Email IDS
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +95,Cannot produce more Item {0} than Sales Order quantity {1},Nelze produkují více položku {0} než prodejní objednávky množství {1}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_list.js +23,Set as Unstopped,Nastavit jako nezastavěnou
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +440,Stock Entry {0} is not submitted,Sklad Entry {0} není předložena
-DocType: Payment Reconciliation,Bank / Cash Account,Bank / Peněžní účet
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +43,This Leave Application is pending approval. Only the Leave Approver can update status.,To Leave Aplikace je čeká na schválení. Pouze Leave schvalovač aktualizovat stav.
-DocType: Global Defaults,Hide Currency Symbol,Skrýt symbol měny
-apps/erpnext/erpnext/config/accounts.py +154,"e.g. Bank, Cash, Credit Card","např. banka, hotovost, kreditní karty"
-DocType: Journal Entry,Credit Note,Dobropis
-apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +206,Completed Qty cannot be more than {0} for operation {1},Dokončené množství nemůže být více než {0} pro provoz {1}
-DocType: Features Setup,Quality,Kvalita
-DocType: Contact Us Settings,Introduction,Úvod
-DocType: Warranty Claim,Service Address,Servisní adresy
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +71,Max 100 rows for Stock Reconciliation.,Max 100 řádky pro Stock smíření.
-DocType: Stock Entry,Manufacture,Výroba
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,Dodávka Vezměte prosím na vědomí první
-DocType: Shopping Cart Taxes and Charges Master,Tax Master,Tax Mistr
-DocType: Opportunity,Customer / Lead Name,Zákazník / Lead Name
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +61,Clearance Date not mentioned,Výprodej Datum není uvedeno
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +66,Production,Výroba
-DocType: Item,Allow Production Order,Povolit výrobní objednávky
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.js +60,Row {0}:Start Date must be before End Date,"Row {0}: datum zahájení, musí být před koncem roku Datum"
-apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Total (ks)
-DocType: Installation Note Item,Installed Qty,Instalované množství
-DocType: Lead,Fax,Fax
-DocType: Purchase Taxes and Charges,Parenttype,Parenttype
-sites/assets/js/list.min.js +26,Submitted,Vloženo
-DocType: Salary Structure,Total Earning,Celkem Zisk
-DocType: Purchase Receipt,Time at which materials were received,"Čas, kdy bylo přijato materiály"
-apps/erpnext/erpnext/config/hr.py +100,Organization branch master.,Organizace větev master.
-DocType: Purchase Invoice,Will be calculated automatically when you enter the details,"Bude vypočtena automaticky, když zadáte detaily"
-DocType: Delivery Note,Transporter lorry number,Transporter číslo nákladní auto
-DocType: Sales Order,Billing Status,Status Fakturace
-DocType: Backup Manager,Backup Right Now,Zálohovat hned
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +135,Utility Expenses,Utility Náklady
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +45,90-Above,90 Nad
-DocType: Buying Settings,Default Buying Price List,Výchozí Nákup Ceník
-DocType: Notification Control,Sales Order Message,Prodejní objednávky Message
-apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Nastavit jako výchozí hodnoty, jako je společnost, měna, aktuálním fiskálním roce, atd"
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.js +20,Payment Type,Typ platby
-DocType: Salary Manager,Select Employees,Vybrat Zaměstnanci
-DocType: Bank Reconciliation,To Date,To Date
-DocType: Opportunity,Potential Sales Deal,Potenciální prodej
-sites/assets/js/form.min.js +286,Details,Podrobnosti
-DocType: Purchase Invoice,Total Taxes and Charges,Celkem Daně a poplatky
-DocType: Email Digest,Payments Made,Platby provedené
-DocType: Employee,Emergency Contact,Kontakt v nouzi
-DocType: Item,Quality Parameters,Parametry kvality
-DocType: Target Detail,Target  Amount,Cílová částka
-DocType: Shopping Cart Settings,Shopping Cart Settings,Nákupní košík Nastavení
-DocType: Journal Entry,Accounting Entries,Účetní záznamy
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},Duplicitní záznam. Zkontrolujte autorizační pravidlo {0}
-DocType: Purchase Order,Ref SQ,Ref SQ
-apps/erpnext/erpnext/config/manufacturing.py +56,Replace Item / BOM in all BOMs,Nahradit položky / kusovníky ve všech kusovníků
-DocType: Purchase Order Item,Received Qty,Přijaté Množství
-DocType: Stock Entry Detail,Serial No / Batch,Výrobní číslo / Batch
-DocType: Sales BOM,Parent Item,Nadřazená položka
-DocType: Account,Account Type,Typ účtu
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +222,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Plán údržby není generován pro všechny položky. Prosím, klikněte na ""Generovat Schedule"""
-,To Produce,K výrobě
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +119,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Pro řádek {0} v {1}. Chcete-li v rychlosti položku jsou {2}, řádky {3} musí být také zahrnuty"
-DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikace balíčku pro dodávky (pro tisk)
-DocType: Bin,Reserved Quantity,Vyhrazeno Množství
-DocType: Landed Cost Voucher,Purchase Receipt Items,Položky příjemky
-DocType: Party Type,Parent Party Type,Parent Type Party
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +61,Cutting,Výstřižek
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +68,Flattening,Zploštění
-apps/erpnext/erpnext/setup/doctype/backup_manager/backup_manager.js +27,Backups will be uploaded to,Zálohy budou nahrány na
-DocType: Account,Income Account,Účet příjmů
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +21,Molding,Lití
-DocType: Stock Reconciliation Item,Current Qty,Aktuální Množství
-DocType: BOM Item,"See ""Rate Of Materials Based On"" in Costing Section","Viz ""Hodnotit materiálů na bázi"" v kapitole Costing"
-DocType: Appraisal Goal,Key Responsibility Area,Key Odpovědnost Area
-DocType: Item Reorder,Material Request Type,Materiál Typ požadavku
-apps/frappe/frappe/desk/moduleview.py +61,Documents,Dokumenty
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +17,Ref,Ref
-DocType: Cost Center,Cost Center,Nákladové středisko
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.js +48,Voucher #,Voucher #
-DocType: Notification Control,Purchase Order Message,Zprávy vydané objenávky
-DocType: Upload Attendance,Upload HTML,Nahrát HTML
-apps/erpnext/erpnext/controllers/accounts_controller.py +323,"Total advance ({0}) against Order {1} cannot be greater \
+Note,Poznámka,
+New Material Requests,Nové žádosti Materiál,
+Recd Quantity,Recd Množstva,
+Email Ids,Email IDS,
+Cannot produce more Item {0} than Sales Order quantity {1},Nelze produkují více položku {0} než prodejní objednávky množství {1}
+Set as Unstopped,Nastavit jako nezastavěnou,
+Stock Entry {0} is not submitted,Sklad Entry {0} není předložena,
+Bank / Cash Account,Bank / Peněžní účet,
+This Leave Application is pending approval. Only the Leave Approver can update status.,To Leave Aplikace je čeká na schválení. Pouze Leave schvalovač aktualizovat stav.
+Hide Currency Symbol,Skrýt symbol měny,
+"e.g. Bank, Cash, Credit Card","např. banka, hotovost, kreditní karty"
+Credit Note,Dobropis,
+Completed Qty cannot be more than {0} for operation {1},Dokončené množství nemůže být více než {0} pro provoz {1}
+Quality,Kvalita,
+Introduction,Úvod,
+Service Address,Servisní adresy,
+Max 100 rows for Stock Reconciliation.,Max 100 řádky pro Stock smíření.
+Manufacture,Výroba,
+Please Delivery Note first,Dodávka Vezměte prosím na vědomí prvna,
+Tax Master,Tax Mistr,
+Customer / Lead Name,Zákazník / Lead Name,
+Clearance Date not mentioned,Výprodej Datum není uvedeno,
+Production,Výroba,
+Allow Production Order,Povolit výrobní objednávky,
+Row {0}:Start Date must be before End Date,"Row {0}: datum zahájení, musí být před koncem roku Datum"
+Total(Qty),Total (ks)
+Installed Qty,Instalované množstvx,
+Fax,Fax,
+Parenttype,Parenttype,
+Submitted,Vloženo,
+Total Earning,Celkem Zisk,
+Time at which materials were received,"Čas, kdy bylo přijato materiály"
+Organization branch master.,Organizace větev master.
+Will be calculated automatically when you enter the details,"Bude vypočtena automaticky, když zadáte detaily"
+Transporter lorry number,Transporter číslo nákladní auto,
+Billing Status,Status Fakturace,
+Backup Right Now,Zálohovat hned,
+Utility Expenses,Utility Náklady,
+90-Above,90 Nad,
+Default Buying Price List,Výchozí Nákup Ceník,
+Sales Order Message,Prodejní objednávky Message,
+"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Nastavit jako výchozí hodnoty, jako je společnost, měna, aktuálním fiskálním roce, atd"
+Payment Type,Typ platby,
+Select Employees,Vybrat Zaměstnanci,
+To Date,To Date,
+Potential Sales Deal,Potenciální prodej,
+Details,Podrobnosti,
+Total Taxes and Charges,Celkem Daně a poplatky,
+Payments Made,Platby provedeny,
+Emergency Contact,Kontakt v nouzi,
+Quality Parameters,Parametry kvality,
+Target  Amount,Cílová částka,
+Shopping Cart Settings,Nákupní košík Nastaveny,
+Accounting Entries,Účetní záznamy,
+Duplicate Entry. Please check Authorization Rule {0},Duplicitní záznam. Zkontrolujte autorizační pravidlo {0}
+Ref SQ,Ref SQ,
+Replace Item / BOM in all BOMs,Nahradit položky / kusovníky ve všech kusovníkQ,
+Received Qty,Přijaté MnožstvQ,
+Serial No / Batch,Výrobní číslo / Batch,
+Parent Item,Nadřazená položka,
+Account Type,Typ účtu,
+Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Plán údržby není generován pro všechny položky. Prosím, klikněte na ""Generovat Schedule"""
+To Produce,K výrob$1,
+"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Pro řádek {0} v {1}. Chcete-li v rychlosti položku jsou {2}, řádky {3} musí být také zahrnuty"
+Identification of the package for the delivery (for print),Identifikace balíčku pro dodávky (pro tisk)
+Reserved Quantity,Vyhrazeno Množstvy,
+Purchase Receipt Items,Položky příjemky,
+Parent Party Type,Parent Type Party,
+Cutting,Výstřižek,
+Flattening,Zploštěny,
+Backups will be uploaded to,Zálohy budou nahrány na,
+Income Account,Účet příjmy,
+Molding,Lity,
+Current Qty,Aktuální Množstvy,
+"See ""Rate Of Materials Based On"" in Costing Section","Viz ""Hodnotit materiálů na bázi"" v kapitole Costing"
+Key Responsibility Area,Key Odpovědnost Area,
+Material Request Type,Materiál Typ požadavku,
+Documents,Dokumenty,
+Ref,Ref,
+Cost Center,Nákladové středisko,
+Voucher #,Voucher #
+Purchase Order Message,Zprávy vydané objenávky,
+Upload HTML,Nahrát HTML,
+"Total advance ({0}) against Order {1} cannot be greater \
 				than the Grand Total ({2})","Celkem předem ({0}) na objednávku {1} nemůže být větší než \
  celkovém součtu ({2})"
-DocType: Employee,Relieving Date,Uvolnění Datum
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +12,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Ceny Pravidlo je vyrobena přepsat Ceník / definovat slevy procenta, na základě určitých kritérií."
-DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Sklad je možné provést pouze prostřednictvím Burzy Entry / dodací list / doklad o zakoupení
-DocType: Employee Education,Class / Percentage,Třída / Procento
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +87,Head of Marketing and Sales,Vedoucí marketingu a prodeje
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +31,Income Tax,Daň z příjmů
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +156,Laser engineered net shaping,Laser technicky čisté tvarování
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +15,"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.","Je-li zvolena Ceny pravidlo je určen pro ""Cena"", přepíše ceníku. Ceny Pravidlo cena je konečná cena, a proto by měla být použita žádná další sleva. Proto, v transakcích, jako odběratele, objednávky atd, bude stažen v oboru ""sazbou"", spíše než poli ""Ceník sazby""."
-apps/erpnext/erpnext/config/selling.py +158,Track Leads by Industry Type.,Trasa vede od průmyslu typu.
-DocType: Item Supplier,Item Supplier,Položka Dodavatel
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +331,Please enter Item Code to get batch no,"Prosím, zadejte kód položky se dostat dávku no"
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +679,Please select a value for {0} quotation_to {1},Vyberte prosím hodnotu pro {0} quotation_to {1}
-DocType: Global Defaults,For automatic exchange rates go to jsonrates.com and signup for an API key,U automatických směnných kurzů jít do jsonrates.com a zaregistrovat pro klíč API
-apps/erpnext/erpnext/config/selling.py +33,All Addresses.,Všechny adresy.
-DocType: Company,Stock Settings,Stock Nastavení
-DocType: User,Bio,Biografie
-apps/erpnext/erpnext/accounts/doctype/account/account.py +166,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spojení je možné pouze tehdy, pokud tyto vlastnosti jsou stejné v obou záznamech. Je Group, Root Type, Company"
-apps/erpnext/erpnext/config/crm.py +62,Manage Customer Group Tree.,Správa zákazníků skupiny Tree.
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +278,New Cost Center Name,Jméno Nového Nákladového Střediska
-DocType: Leave Control Panel,Leave Control Panel,Nechte Ovládací panely
-apps/erpnext/erpnext/utilities/doctype/address/address.py +67,No default Address Template found. Please create a new one from Setup > Printing and Branding > Address Template.,"No default šablony adresy nalezeno. Prosím, vytvořte nový z Nastavení> Tisk a značky> Adresa šablonu."
-DocType: Appraisal,HR User,HR User
-DocType: Purchase Invoice,Taxes and Charges Deducted,Daně a odečtené
-apps/erpnext/erpnext/shopping_cart/utils.py +47,Issues,Problémy
-apps/erpnext/erpnext/utilities/__init__.py +24,Status must be one of {0},Stav musí být jedním z {0}
-DocType: Sales Invoice,Debit To,Debetní K
-DocType: Delivery Note,Required only for sample item.,Požadováno pouze pro položku vzorku.
-DocType: Stock Ledger Entry,Actual Qty After Transaction,Skutečné Množství Po transakci
-,Pending SO Items For Purchase Request,"Do doby, než SO položky k nákupu Poptávka"
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +143,Extra Large,Extra Velké
-,Profit and Loss Statement,Výkaz zisků a ztrát
-DocType: Bank Reconciliation Detail,Cheque Number,Šek číslo
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +42,Pressing,Stisknutí
-DocType: Payment Tool Detail,Payment Tool Detail,Detail platební nástroj
-,Sales Browser,Sales Browser
-DocType: Journal Entry,Total Credit,Celkový Credit
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +443,Warning: Another {0} # {1} exists against stock entry {2},Upozornění: Dalším {0} # {1} existuje proti akciové vstupu {2}
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +390,Local,Místní
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Úvěrů a půjček (aktiva)
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Dlužníci
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +142,Large,Velký
-apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +18,No employee found!,Žádný zaměstnanec našel!
-DocType: C-Form Invoice Detail,Territory,Území
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +162,Please mention no of visits required,"Prosím, uveďte počet požadovaných návštěv"
-DocType: Stock Settings,Default Valuation Method,Výchozí metoda ocenění
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +126,Polishing,Leštění
-DocType: Production Order Operation,Planned Start Time,Plánované Start Time
-apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +46,Allocated,Přidělené
-apps/erpnext/erpnext/config/accounts.py +63,Close Balance Sheet and book Profit or Loss.,Zavřete Rozvahu a zapiš účetní zisk nebo ztrátu.
-DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Zadejte Exchange Rate převést jednu měnu na jinou
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +81,Row{0}: Party Type and Party is only applicable against Receivable / Payable account,Row {0}: Type Party Party a je použitelná pouze na pohledávky / závazky účet
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +135,Quotation {0} is cancelled,Nabídka {0} je zrušena
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +26,Total Outstanding Amount,Celková dlužná částka
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} was on leave on {1}. Cannot mark attendance.,Zaměstnanec {0} byl na dovolené na {1}. Nelze označit účast.
-DocType: Sales Partner,Targets,Cíle
-DocType: Price List,Price List Master,Ceník Master
-DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Všechny prodejní transakce mohou být označeny proti více ** prodejcům **, takže si můžete nastavit a sledovat cíle."
-,S.O. No.,SO Ne.
-DocType: Production Order Operation,Make Time Log,Udělejte si čas Přihlásit
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +162,Please create Customer from Lead {0},Prosím vytvořte Zákazník z olova {0}
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +44,Computers,Počítače
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +111,Electro-chemical grinding,Electro-chemické broušení
-apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +14,This is a root customer group and cannot be edited.,"To je kořen skupiny zákazníků, a nelze upravovat."
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +39,Please setup your chart of accounts before you start Accounting Entries,"Prosím, nastavit svůj účtový rozvrh, než začnete účetních zápisů"
-DocType: Purchase Invoice,Ignore Pricing Rule,Ignorovat Ceny pravidlo
-sites/assets/js/list.min.js +23,Cancelled,Zrušeno
-DocType: Employee Education,Graduate,Absolvent
-DocType: Leave Block List,Block Days,Blokové dny
-DocType: Journal Entry,Excise Entry,Spotřební Entry
-DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.
+Relieving Date,Uvolnění Datum,
+"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Ceny Pravidlo je vyrobena přepsat Ceník / definovat slevy procenta, na základě určitých kritérií."
+Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Sklad je možné provést pouze prostřednictvím Burzy Entry / dodací list / doklad o zakoupeno,
+Class / Percentage,Třída / Procento,
+Head of Marketing and Sales,Vedoucí marketingu a prodeje,
+Income Tax,Daň z příjmo,
+Laser engineered net shaping,Laser technicky čisté tvarováno,
+"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.","Je-li zvolena Ceny pravidlo je určen pro ""Cena"", přepíše ceníku. Ceny Pravidlo cena je konečná cena, a proto by měla být použita žádná další sleva. Proto, v transakcích, jako odběratele, objednávky atd, bude stažen v oboru ""sazbou"", spíše než poli ""Ceník sazby""."
+Track Leads by Industry Type.,Trasa vede od průmyslu typu.
+Item Supplier,Položka Dodavatel,
+Please enter Item Code to get batch no,"Prosím, zadejte kód položky se dostat dávku no"
+Please select a value for {0} quotation_to {1},Vyberte prosím hodnotu pro {0} quotation_to {1}
+For automatic exchange rates go to jsonrates.com and signup for an API key,U automatických směnných kurzů jít do jsonrates.com a zaregistrovat pro klíč API,
+All Addresses.,Všechny adresy.
+Stock Settings,Stock Nastavene,
+Bio,Biografie,
+"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spojení je možné pouze tehdy, pokud tyto vlastnosti jsou stejné v obou záznamech. Je Group, Root Type, Company"
+Manage Customer Group Tree.,Správa zákazníků skupiny Tree.
+New Cost Center Name,Jméno Nového Nákladového Střediska,
+Leave Control Panel,Nechte Ovládací panely,
+No default Address Template found. Please create a new one from Setup > Printing and Branding > Address Template.,"No default šablony adresy nalezeno. Prosím, vytvořte nový z Nastavení> Tisk a značky> Adresa šablonu."
+HR User,HR User,
+Taxes and Charges Deducted,Daně a odečtenr,
+Issues,Problémy,
+Status must be one of {0},Stav musí být jedním z {0}
+Debit To,Debetní K,
+Required only for sample item.,Požadováno pouze pro položku vzorku.
+Actual Qty After Transaction,Skutečné Množství Po transakci,
+Pending SO Items For Purchase Request,"Do doby, než SO položky k nákupu Poptávka"
+Extra Large,Extra Velkt,
+Profit and Loss Statement,Výkaz zisků a ztrát,
+Cheque Number,Šek číslo,
+Pressing,Stisknutt,
+Payment Tool Detail,Detail platební nástroj,
+Sales Browser,Sales Browser,
+Total Credit,Celkový Credit,
+Warning: Another {0} # {1} exists against stock entry {2},Upozornění: Dalším {0} # {1} existuje proti akciové vstupu {2}
+Local,Místn$1,
+Loans and Advances (Assets),Úvěrů a půjček (aktiva)
+Debtors,Dlužníci,
+Large,Velki,
+No employee found!,Žádný zaměstnanec našel!
+Territory,Územ$1,
+Please mention no of visits required,"Prosím, uveďte počet požadovaných návštěv"
+Default Valuation Method,Výchozí metoda oceněne,
+Polishing,Leštěne,
+Planned Start Time,Plánované Start Time,
+Allocated,Přidělene,
+Close Balance Sheet and book Profit or Loss.,Zavřete Rozvahu a zapiš účetní zisk nebo ztrátu.
+Specify Exchange Rate to convert one currency into another,Zadejte Exchange Rate převést jednu měnu na jinou,
+Row{0}: Party Type and Party is only applicable against Receivable / Payable account,Row {0}: Type Party Party a je použitelná pouze na pohledávky / závazky účet,
+Quotation {0} is cancelled,Nabídka {0} je zrušena,
+Total Outstanding Amount,Celková dlužná částka,
+Employee {0} was on leave on {1}. Cannot mark attendance.,Zaměstnanec {0} byl na dovolené na {1}. Nelze označit účast.
+Targets,Cíle,
+Price List Master,Ceník Master,
+All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Všechny prodejní transakce mohou být označeny proti více ** prodejcům **, takže si můžete nastavit a sledovat cíle."
+S.O. No.,SO Ne.
+Make Time Log,Udělejte si čas Přihlásit,
+Please create Customer from Lead {0},Prosím vytvořte Zákazník z olova {0}
+Computers,Počítače,
+Electro-chemical grinding,Electro-chemické broušene,
+This is a root customer group and cannot be edited.,"To je kořen skupiny zákazníků, a nelze upravovat."
+Please setup your chart of accounts before you start Accounting Entries,"Prosím, nastavit svůj účtový rozvrh, než začnete účetních zápisů"
+Ignore Pricing Rule,Ignorovat Ceny pravidlo,
+Cancelled,Zrušeno,
+Graduate,Absolvent,
+Block Days,Blokové dny,
+Excise Entry,Spotřební Entry,
+"Standard Terms and Conditions that can be added to Sales and Purchases.
 
 Examples:
 
@@ -2228,1172 +2228,1172 @@
  1. Podmínky přepravy, v případě potřeby.
  1. Způsoby řešení sporů, náhrady škody, odpovědnosti za škodu, atd 
  1. Adresa a kontakt na vaši společnost."
-DocType: Attendance,Leave Type,Leave Type
-apps/erpnext/erpnext/controllers/stock_controller.py +171,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Náklady / Rozdíl účtu ({0}), musí být ""zisk nebo ztráta"" účet"
-DocType: Account,Accounts User,Uživatel Účtů
-DocType: Purchase Invoice,"Check if recurring invoice, uncheck to stop recurring or put proper End Date","Zkontrolujte, zda je opakující se faktury, zrušte zaškrtnutí zastavit opakované nebo dát správné datum ukončení"
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,Attendance for employee {0} is already marked,Účast na zaměstnance {0} je již označen
-DocType: Packing Slip,If more than one package of the same type (for print),Pokud je více než jeden balík stejného typu (pro tisk)
-apps/erpnext/erpnext/utilities/doctype/rename_tool/rename_tool.py +38,Maximum {0} rows allowed,Maximálně {0} řádků povoleno
-DocType: C-Form Invoice Detail,Net Total,Net Total
-DocType: Bin,FCFS Rate,FCFS Rate
-apps/erpnext/erpnext/accounts/page/pos/pos.js +15,Billing (Sales Invoice),Fakturace (Prodejní Faktura)
-DocType: Payment Reconciliation Invoice,Outstanding Amount,Dlužné částky
-DocType: Project Task,Working,Pracovní
-DocType: Stock Ledger Entry,Stock Queue (FIFO),Sklad fronty (FIFO)
-apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +13,Please select Time Logs.,Vyberte Time Protokoly.
-apps/erpnext/erpnext/accounts/doctype/pos_setting/pos_setting.py +43,{0} does not belong to Company {1},{0} nepatří do Společnosti {1}
-,Requested Qty,Požadované množství
-DocType: BOM Item,Scrap %,Scrap%
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +38,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Poplatky budou rozděleny úměrně na základě položky Množství nebo částkou, dle Vašeho výběru"
-DocType: Maintenance Visit,Purposes,Cíle
-apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +67,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Provoz {0} déle, než všech dostupných pracovních hodin v pracovní stanici {1}, rozložit provoz do několika operací"
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +133,Electrochemical machining,Elektrochemické obrábění
-,Requested,Požadované
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +62,No Remarks,Žádné poznámky
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +11,Overdue,Zpožděný
-DocType: Account,Stock Received But Not Billed,Sklad nepřijali Účtovaný
-DocType: Salary Slip,Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,Gross Pay + nedoplatek Částka + Inkaso Částka - Total Odpočet
-DocType: Monthly Distribution,Distribution Name,Distribuce Name
-DocType: Features Setup,Sales and Purchase,Prodej a nákup
-DocType: Pricing Rule,Price / Discount,Cena / Sleva
-DocType: Purchase Order Item,Material Request No,Materiál Poptávka No
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +201,Quality Inspection required for Item {0},Kontrola kvality potřebný k bodu {0}
-DocType: Quotation,Rate at which customer's currency is converted to company's base currency,"Sazba, za kterou zákazník měny je převeden na společnosti základní měny"
-DocType: Purchase Invoice,Discount Amount (Company Currency),Částka slevy (Company Měna)
-apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +105,{0} has been successfully unsubscribed from this list.,{0} byl úspěšně odhlášen z tohoto seznamu.
-DocType: Purchase Invoice Item,Net Rate (Company Currency),Čistý Rate (Company měny)
-apps/erpnext/erpnext/config/crm.py +71,Manage Territory Tree.,Správa Territory strom.
-DocType: Payment Reconciliation Payment,Sales Invoice,Prodejní faktury
-DocType: Journal Entry Account,Party Balance,Balance Party
-DocType: Sales Invoice Item,Time Log Batch,Time Log Batch
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +344,Please select Apply Discount On,"Prosím, vyberte Použít Sleva na"
-DocType: Company,Default Receivable Account,Výchozí pohledávek účtu
-DocType: Salary Manager,Create Bank Entry for the total salary paid for the above selected criteria,Vytvoření bankovní položka pro celkové vyplacené mzdy za výše zvolených kritérií
-DocType: Item,Item will be saved by this name in the data base.,Bod budou uloženy pod tímto jménem v databázi.
-DocType: Stock Entry,Material Transfer for Manufacture,Materiál Přenos: Výroba
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +18,Discount Percentage can be applied either against a Price List or for all Price List.,Sleva v procentech lze použít buď proti Ceníku nebo pro všechny Ceníku.
-DocType: Purchase Invoice,Half-yearly,Pololetní
-apps/erpnext/erpnext/accounts/report/financial_statements.py +16,Fiscal Year {0} not found.,Fiskální rok {0} nebyl nalezen.
-DocType: Bank Reconciliation,Get Relevant Entries,Získat příslušné zápisy
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +299,Accounting Entry for Stock,Účetní položka na skladě
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +63,Coining,Ražení
-DocType: Sales Invoice,Sales Team1,Sales Team1
-apps/erpnext/erpnext/stock/doctype/item/item.py +408,Item {0} does not exist,Bod {0} neexistuje
-DocType: Item,"Selecting ""Yes"" will allow you to make a Production Order for this item.","Výběrem ""Yes"" vám umožní, aby se výrobní zakázku pro tuto položku."
-DocType: Sales Invoice,Customer Address,Zákazník Address
-DocType: Purchase Invoice,Total,Celkem
-DocType: Backup Manager,System for managing Backups,Systém pro správu zálohování
-DocType: Account,Root Type,Root Type
-apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +52,Plot,Spiknutí
-DocType: Item Group,Show this slideshow at the top of the page,Zobrazit tuto prezentaci v horní části stránky
-DocType: BOM,Item UOM,Položka UOM
-DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Částka daně po slevě Částka (Company měny)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +165,Target warehouse is mandatory for row {0},Target sklad je povinná pro řadu {0}
-DocType: Quality Inspection,Quality Inspection,Kontrola kvality
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +139,Extra Small,Extra Malé
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +19,Spray forming,Spray tváření
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +468,Warning: Material Requested Qty is less than Minimum Order Qty,Upozornění: Materiál Požadované množství je menší než minimální objednávka Množství
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +157,Account {0} is frozen,Účet {0} je zmrazen
-DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,"Právní subjekt / dceřiná společnost s oddělenou Graf účtů, které patří do organizace."
-apps/erpnext/erpnext/config/setup.py +116,Address master.,Adresa master.
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +28,"Food, Beverage & Tobacco","Potraviny, nápoje a tabák"
-apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +20,PL or BS,PL nebo BS
-apps/erpnext/erpnext/controllers/selling_controller.py +127,Commission rate cannot be greater than 100,Rychlost Komise nemůže být větší než 100
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Minimum Inventory Level,Minimální úroveň zásob
-DocType: Stock Entry,Subcontract,Subdodávka
-DocType: Production Planning Tool,Get Items From Sales Orders,Získat položky z Prodejní Objednávky
-DocType: Production Order Operation,Actual End Time,Aktuální End Time
-DocType: Production Planning Tool,Download Materials Required,Ke stažení potřebné materiály:
-DocType: Item,Manufacturer Part Number,Typové označení
-DocType: Production Order Operation,Estimated Time and Cost,Odhadovná doba a náklady
-DocType: Bin,Bin,Popelnice
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +49,Nosing,Zaoblená hrana
-DocType: SMS Log,No of Sent SMS,Počet odeslaných SMS
-DocType: Account,Company,Společnost
-DocType: Account,Expense Account,Účtet nákladů
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +48,Software,Software
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +146,Colour,Barevné
-DocType: Maintenance Visit,Scheduled,Plánované
-DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Vyberte měsíční výplatou na nerovnoměrně distribuovat cílů napříč měsíců.
-DocType: Purchase Invoice Item,Valuation Rate,Ocenění Rate
-DocType: Address,Check to make Shipping Address,Zaškrtněte pro vytvoření doručovací adresy
-apps/erpnext/erpnext/stock/get_item_details.py +253,Price List Currency not selected,Ceníková Měna není zvolena
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {0}: Purchase Receipt {1} does not exist in above 'Purchase Receipts' table,"Bod Row {0}: doklad o koupi, {1} neexistuje v tabulce ""kupní příjmy"""
-DocType: Pricing Rule,Applicability,Použitelnost
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +135,Employee {0} has already applied for {1} between {2} and {3},Zaměstnanec {0} již požádal o {1} mezi {2} a {3}
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Datum zahájení projektu
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +8,Until,Dokud
-DocType: Rename Tool,Rename Log,Přejmenovat Přihlásit
-DocType: Installation Note Item,Against Document No,Proti dokumentu č
-apps/erpnext/erpnext/config/selling.py +93,Manage Sales Partners.,Správa prodejních partnerů.
-DocType: Quality Inspection,Inspection Type,Kontrola Type
-apps/erpnext/erpnext/controllers/recurring_document.py +160,Please select {0},"Prosím, vyberte {0}"
-DocType: C-Form,C-Form No,C-Form No
-DocType: BOM,Exploded_items,Exploded_items
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +90,Researcher,Výzkumník
-apps/frappe/frappe/custom/doctype/customize_form/customize_form.js +87,Update,Aktualizovat
-apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +75,Please save the Newsletter before sending,Uložte Newsletter před odesláním
-apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +23,Name or Email is mandatory,Jméno nebo e-mail je povinné
-apps/erpnext/erpnext/config/stock.py +74,Incoming quality inspection.,Vstupní kontrola jakosti.
-DocType: Employee,Exit,Východ
-apps/erpnext/erpnext/accounts/doctype/account/account.py +108,Root Type is mandatory,Root Type je povinné
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +292,Serial No {0} created,Pořadové číslo {0} vytvořil
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +124,Vibratory finishing,Vibrační dokončovací
-DocType: Item,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Pro pohodlí zákazníků, tyto kódy mohou být použity v tiskových formátech, jako na fakturách a dodacích listech"
-DocType: Journal Entry Account,Against Purchase Order,Proti vydané objednávce
-DocType: Employee,You can enter any date manually,Můžete zadat datum ručně
-DocType: Sales Invoice,Advertisement,Reklama
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +160,Probationary Period,Zkušební doba
-DocType: Customer Group,Only leaf nodes are allowed in transaction,Pouze koncové uzly jsou povoleny v transakci
-DocType: Expense Claim,Expense Approver,Schvalovatel výdajů
-DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Doklad o koupi Item Dodávané
-sites/assets/js/erpnext.min.js +43,Pay,Platit
-apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +17,To Datetime,Chcete-li datetime
-DocType: SMS Settings,SMS Gateway URL,SMS brána URL
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +136,Grinding,Broušení
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +33,Shrink wrapping,Zmenšit balení
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +52,Supplier > Supplier Type,Dodavatel> Dodavatel Type
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +123,Please enter relieving date.,Zadejte zmírnění datum.
-apps/erpnext/erpnext/controllers/trends.py +137,Amt,Amt
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +237,Serial No {0} status must be 'Available' to Deliver,"Pořadové číslo {0} status musí být ""k dispozici"" doručovat"
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52,Only Leave Applications with status 'Approved' can be submitted,"Nechte pouze aplikace s status ""schváleno"" může být předloženy"
-apps/erpnext/erpnext/utilities/doctype/address/address.py +21,Address Title is mandatory.,Adresa Název je povinný.
-DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,"Zadejte název kampaně, pokud zdroj šetření je kampaň"
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +37,Newspaper Publishers,Vydavatelé novin
-apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +31,Select Fiscal Year,Vyberte Fiskální rok
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +87,Smelting,Tavba rudy
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +40,You are the Leave Approver for this record. Please Update the 'Status' and Save,"Jste Leave schvalujícím pro tento záznam. Prosím aktualizujte ""stavu"" a Uložit"
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Změna pořadí Level
-DocType: Attendance,Attendance Date,Účast Datum
-DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Plat rozpad na základě Zisk a dedukce.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +77,Account with child nodes cannot be converted to ledger,Účet s podřízenými uzly nelze převést na hlavní účetní knihu
-DocType: Address,Preferred Shipping Address,Preferovaná dodací adresa
-DocType: Purchase Receipt Item,Accepted Warehouse,Schválené Sklad
-DocType: Bank Reconciliation Detail,Posting Date,Datum zveřejnění
-DocType: Item,Valuation Method,Ocenění Method
-DocType: Sales Invoice,Sales Team,Prodejní tým
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +76,Duplicate entry,Duplicitní záznam
-DocType: Serial No,Under Warranty,V rámci záruky
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +425,[Error],[Chyba]
-DocType: Sales Order,In Words will be visible once you save the Sales Order.,"Ve slovech budou viditelné, jakmile uložíte prodejní objednávky."
-,Employee Birthday,Narozeniny zaměstnance
-DocType: GL Entry,Debit Amt,Debetní Amt
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +54,Venture Capital,Venture Capital
-DocType: UOM,Must be Whole Number,Musí být celé číslo
-DocType: Leave Control Panel,New Leaves Allocated (In Days),Nové Listy Přidělené (ve dnech)
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +51,Serial No {0} does not exist,Pořadové číslo {0} neexistuje
-DocType: Pricing Rule,Discount Percentage,Sleva v procentech
-DocType: Payment Reconciliation Invoice,Invoice Number,Číslo faktury
-apps/erpnext/erpnext/shopping_cart/utils.py +44,Orders,Objednávky
-DocType: Leave Control Panel,Employee Type,Type zaměstnanců
-DocType: Employee Leave Approver,Leave Approver,Nechte schvalovač
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +69,Swaging,Zužování
-DocType: Expense Claim,"A user with ""Expense Approver"" role","Uživatel s rolí ""Schvalovatel výdajů"""
-,Issued Items Against Production Order,Vydané předmětů proti výrobní zakázky
-DocType: Pricing Rule,Purchase Manager,Vedoucí nákupu
-DocType: Payment Tool,Payment Tool,Platebního nástroje
-DocType: Target Detail,Target Detail,Target Detail
-DocType: Sales Order,% of materials billed against this Sales Order,% Materiálů fakturovaných proti tomuto odběrateli
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +50,Period Closing Entry,Období Uzávěrka Entry
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +36,Cost Center with existing transactions can not be converted to group,Nákladové středisko se stávajícími transakcemi nelze převést do skupiny
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +90,Depreciation,Znehodnocení
-apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),Dodavatel (é)
-DocType: Email Digest,Payments received during the digest period,Platby přijaté během období digest
-DocType: Customer,Credit Limit,Úvěrový limit
-DocType: Features Setup,To enable <b>Point of Sale</b> features,Chcete-li povolit <b> Point of Sale </ b> funkce
-DocType: Purchase Receipt,LR Date,LR Datum
-apps/erpnext/erpnext/accounts/page/pos/pos_page.html +4,Select type of transaction,Vyberte typ transakce
-DocType: GL Entry,Voucher No,Voucher No
-DocType: Leave Allocation,Leave Allocation,Nechte Allocation
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +398,'Update Stock' for Sales Invoice {0} must be set,"Musí být nastavena ""Aktualizace Skladu"" pro prodejní faktury {0}"
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +402,Material Requests {0} created,Materiál Žádosti {0} vytvořené
-apps/erpnext/erpnext/config/selling.py +117,Template of terms or contract.,Šablona podmínek nebo smlouvy.
-DocType: Employee,Feedback,Zpětná vazba
-apps/erpnext/erpnext/accounts/party.py +192,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Poznámka: Z důvodu / Referenční datum překračuje povolené zákazníků úvěrové dní od {0} den (s)
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +107,Abrasive jet machining,Brusné jet obrábění
-DocType: Stock Settings,Freeze Stock Entries,Freeze Stock Příspěvky
-DocType: Website Settings,Website Settings,Nastavení www stránky
-DocType: Activity Cost,Billing Rate,Fakturace Rate
-,Qty to Deliver,Množství k dodání
-DocType: Monthly Distribution Percentage,Month,Měsíc
-,Stock Analytics,Stock Analytics
-DocType: Installation Note Item,Against Document Detail No,Proti Detail dokumentu č
-DocType: Quality Inspection,Outgoing,Vycházející
-DocType: Material Request,Requested For,Požadovaných pro
-DocType: Quotation Item,Against Doctype,Proti DOCTYPE
-DocType: Delivery Note,Track this Delivery Note against any Project,Sledovat tento dodacím listu proti jakémukoli projektu
-apps/erpnext/erpnext/accounts/doctype/account/account.py +141,Root account can not be deleted,Root účet nemůže být smazán
-DocType: GL Entry,Credit Amt,Credit Amt
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +72,Show Stock Entries,Zobrazit Stock Příspěvky
-DocType: Production Order,Work-in-Progress Warehouse,Work-in-Progress sklad
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +273,Reference #{0} dated {1},Reference # {0} ze dne {1}
-DocType: Pricing Rule,Item Code,Kód položky
-DocType: Supplier,Material Manager,Materiál Správce
-DocType: Production Planning Tool,Create Production Orders,Vytvoření výrobní zakázky
-DocType: Time Log,Costing Rate (per hour),Kalkulace Rate (za hodinu)
-DocType: Serial No,Warranty / AMC Details,Záruka / AMC Podrobnosti
-DocType: Journal Entry,User Remark,Uživatel Poznámka
-apps/erpnext/erpnext/config/accounts.py +117,Point-of-Sale Setting,Nastavení Místa Prodeje
-DocType: Lead,Market Segment,Segment trhu
-DocType: Communication,Phone,Telefon
-DocType: Purchase Invoice,Supplier (Payable) Account,Dodavatel (za poplatek) Account
-DocType: Employee Internal Work History,Employee Internal Work History,Interní historie práce zaměstnance
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +192,Closing (Dr),Uzavření (Dr)
-DocType: Contact,Passive,Pasivní
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +242,Serial No {0} not in stock,Pořadové číslo {0} není skladem
-apps/erpnext/erpnext/config/selling.py +122,Tax template for selling transactions.,Daňové šablona na prodej transakce.
-DocType: Sales Invoice,Write Off Outstanding Amount,Odepsat dlužné částky
-DocType: Features Setup,"Check if you need automatic recurring invoices. After submitting any sales invoice, Recurring section will be visible.","Zkontrolujte, zda potřebujete automatické opakující faktury. Po odeslání jakékoliv prodejní fakturu, opakující se část bude viditelný."
-DocType: Account,Accounts Manager,Accounts Manager
-apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.py +36,Time Log {0} must be 'Submitted',"Time Log {0} musí být ""Odesláno"""
-DocType: Stock Settings,Default Stock UOM,Výchozí Skladem UOM
-DocType: Production Planning Tool,Create Material Requests,Vytvořit Žádosti materiálu
-DocType: Employee Education,School/University,Škola / University
-DocType: Sales Invoice Item,Available Qty at Warehouse,Množství k dispozici na skladu
-,Billed Amount,Fakturovaná částka
-DocType: Bank Reconciliation,Bank Reconciliation,Bank Odsouhlasení
-DocType: Purchase Invoice,Total Amount To Pay,Celková částka k Zaplatit
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +174,Material Request {0} is cancelled or stopped,Materiál Request {0} je zrušena nebo zastavena
-DocType: Event,Groups,Skupiny
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +85,Group by Account,Seskupit podle účtu
-DocType: Sales Order,Fully Delivered,Plně Dodáno
-DocType: Lead,Lower Income,S nižšími příjmy
-DocType: Period Closing Voucher,"The account head under Liability, in which Profit/Loss will be booked","Účet hlavu pod odpovědnosti, ve kterém se bude Zisk / ztráta rezervovali"
-DocType: Payment Tool,Against Vouchers,Proti Poukázky
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +23,Quick Help,Rychlá pomoc
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +184,Source and target warehouse cannot be same for row {0},Zdroj a cíl sklad nemůže být stejná pro řádek {0}
-DocType: Features Setup,Sales Extras,Prodejní Extras
-apps/erpnext/erpnext/accounts/utils.py +311,{0} budget for Account {1} against Cost Center {2} will exceed by {3},{0} rozpočt na účet {1} proti nákladovému středisku {2} bude vyšší o {3}
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +127,Purchase Order number required for Item {0},Číslo vydané objednávky je potřebné k položce {0}
-DocType: Leave Allocation,Carry Forwarded Leaves,Carry Předáno listy
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date',"""Datum DO"" musí být po ""Datum OD"""
-,Stock Projected Qty,Reklamní Plánovaná POČET
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +143,Customer {0} does not belong to project {1},Zákazník {0} nepatří k projektu {1}
-DocType: Warranty Claim,From Company,Od Společnosti
-apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +95,Value or Qty,Hodnota nebo Množství
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +575,Minute,Minuta
-DocType: Purchase Invoice,Purchase Taxes and Charges,Nákup Daně a poplatky
-DocType: Backup Manager,Upload Backups to Dropbox,Nahrát zálohy na Dropbox
-,Qty to Receive,Množství pro příjem
-DocType: Leave Block List,Leave Block List Allowed,Nechte Block List povolena
-apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +104,Conversion factor cannot be in fractions,Konverzní faktor nemůže být ve zlomcích
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +356,You will use it to Login,Budete ho používat k přihlášení
-DocType: Sales Partner,Retailer,Maloobchodník
-apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +128,All Supplier Types,Všechny typy Dodavatele
-apps/erpnext/erpnext/stock/doctype/item/item.py +35,Item Code is mandatory because Item is not automatically numbered,"Kód položky je povinné, protože položka není automaticky číslovány"
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +61,Quotation {0} not of type {1},Nabídka {0} není typu {1}
-DocType: Maintenance Schedule Item,Maintenance Schedule Item,Plán údržby Item
-DocType: Sales Order,%  Delivered,% Dodáno
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +177,Bank Overdraft Account,Kontokorentní úvěr na účtu
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +15,Make Salary Slip,Proveďte výplatní pásce
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +83,Unstop,Uvolnit
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +175,Secured Loans,Zajištěné úvěry
-apps/erpnext/erpnext/utilities/doctype/rename_tool/rename_tool.py +49,Ignored:,Ignorovat: 
-apps/erpnext/erpnext/shopping_cart/__init__.py +68,{0} cannot be purchased using Shopping Cart,{0} není možné zakoupit pomocí Nákupní košík
-apps/erpnext/erpnext/setup/page/setup_wizard/data/sample_home_page.html +3,Awesome Products,Skvělé produkty
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +189,Opening Balance Equity,Počáteční stav Equity
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +80,Cannot approve leave as you are not authorized to approve leaves on Block Dates,Nelze schválit dovolenou si nejste oprávněna schvalovat listy na blok Termíny
-DocType: Appraisal,Appraisal,Ocenění
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +12,Lost-foam casting,Lost-pěna lití
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +46,Drawing,Výkres
-apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +22,Date is repeated,Datum se opakuje
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +149,Leave approver must be one of {0},Nechte Schvalující musí být jedním z {0}
-DocType: Hub Settings,Seller Email,Prodávající E-mail
-DocType: Project,Total Purchase Cost (via Purchase Invoice),Celkové pořizovací náklady (přes nákupní faktury)
-DocType: Workstation Working Hour,Start Time,Start Time
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +183,Select Quantity,Zvolte množství
-DocType: Sales Taxes and Charges Template,"Specify a list of Territories, for which, this Taxes Master is valid","Zadejte seznam území, pro které tato Daně Master je platný"
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,Schválení role nemůže být stejná jako role pravidlo se vztahuje na
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +41,Message Sent,Zpráva byla odeslána
-DocType: Production Plan Sales Order,SO Date,SO Datum
-DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Sazba, za kterou Ceník měna je převeden na zákazníka základní měny"
-DocType: Purchase Invoice Item,Net Amount (Company Currency),Čistá částka (Company Měna)
-DocType: BOM Operation,Hour Rate,Hour Rate
-DocType: Stock Settings,Item Naming By,Položka Pojmenování By
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +650,From Quotation,Z nabídky
-apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +35,Another Period Closing Entry {0} has been made after {1},Další období Uzávěrka Entry {0} byla podána po {1}
-DocType: Production Order,Material Transferred for Manufacturing,Materiál Přenesená pro výrobu
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +25,Account {0} does not exists,Účet {0} neexistuje
-DocType: Purchase Receipt Item,Purchase Order Item No,Číslo položky vydané objednávky
-DocType: System Settings,System Settings,Nastavení systému
-DocType: Project,Project Type,Typ projektu
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16,Either target qty or target amount is mandatory.,Buď cílové množství nebo cílová částka je povinná.
-apps/erpnext/erpnext/config/projects.py +38,Cost of various activities,Náklady na různých aktivit
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +93,Not allowed to update stock transactions older than {0},Není dovoleno měnit obchodů s akciemi starší než {0}
-DocType: Item,Inspection Required,Kontrola Povinné
-DocType: Purchase Invoice Item,PR Detail,PR Detail
-DocType: Sales Order,Fully Billed,Plně Fakturovaný
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Pokladní hotovost
-DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Celková hmotnost balení. Obvykle se čistá hmotnost + obalového materiálu hmotnosti. (Pro tisk)
-DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Uživatelé s touto rolí se mohou nastavit na zmrazené účty a vytvořit / upravit účetní zápisy proti zmrazených účtů
-DocType: Serial No,Is Cancelled,Je Zrušeno
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +291,My Shipments,Moje dodávky
-DocType: Journal Entry,Bill Date,Bill Datum
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +43,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","I když existuje více pravidla pro tvorbu cen s nejvyšší prioritou, pak následující interní priority jsou použity:"
-DocType: Supplier,Supplier Details,Dodavatele Podrobnosti
-DocType: Communication,Recipients,Příjemci
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +145,Screwing,Šroubování
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +95,Knurling,Vroubkování
-DocType: Expense Claim,Approval Status,Stav schválení
-DocType: Hub Settings,Publish Items to Hub,Publikování položky do Hub
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +38,From value must be less than to value in row {0},Z hodnota musí být menší než hodnota v řadě {0}
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +128,Wire Transfer,Bankovní převod
-apps/erpnext/erpnext/accounts/report/bank_clearance_summary/bank_clearance_summary.py +25,Please select Bank Account,"Prosím, vyberte bankovní účet"
-DocType: Newsletter,Create and Send Newsletters,Vytvoření a odeslání Zpravodaje
-sites/assets/js/report.min.js +107,From Date must be before To Date,Datum od musí být dříve než datum do
-DocType: Sales Order,Recurring Order,Opakující se objednávky
-DocType: Company,Default Income Account,Účet Default příjmů
-apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +33,Customer Group / Customer,Zákazník Group / Customer
-DocType: Item Group,Check this if you want to show in website,"Zaškrtněte, pokud chcete zobrazit v webové stránky"
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +189,Welcome to ERPNext,Vítejte na ERPNext
-DocType: Payment Reconciliation Payment,Voucher Detail Number,Voucher Detail Počet
-DocType: Lead,From Customer,Od Zákazníka
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +37,Calls,Volá
-DocType: Project,Total Costing Amount (via Time Logs),Celková kalkulace Částka (přes Time Záznamy)
-DocType: Purchase Order Item Supplied,Stock UOM,Reklamní UOM
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +192,Purchase Order {0} is not submitted,Vydaná objednávka {0} není odeslána
-apps/erpnext/erpnext/stock/doctype/item/item.py +161,{0} {1} is entered more than once in Item Variants table,{0} {1} je vloženo více než jednou v  tabulce Varianty  Položky
-,Projected,Plánovaná
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232,Serial No {0} does not belong to Warehouse {1},Pořadové číslo {0} nepatří do skladu {1}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105,Note: Reference Date exceeds allowed credit days by {0} days for {1} {2},Poznámka: Odkaz Datum překračuje povolené úvěrové dnů od {0} dní na {1} {2}
-apps/erpnext/erpnext/controllers/status_updater.py +96,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Poznámka: Systém nebude kontrolovat přes dobírku a over-rezervace pro item {0} jako množství nebo částka je 0
-DocType: Notification Control,Quotation Message,Zpráva Nabídky
-DocType: Issue,Opening Date,Datum otevření
-apps/erpnext/erpnext/accounts/doctype/pos_setting/pos_setting.py +23,POS Setting {0} already created for user: {1} and company {2},POS nastavení {0} již vytvořili pro uživatele: {1} a společnost {2}
-DocType: Journal Entry,Remark,Poznámka
-DocType: Purchase Receipt Item,Rate and Amount,Tempo a rozsah
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +94,Boring,Nudný
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +680,From Sales Order,Z přijaté objednávky
-DocType: Blog Category,Parent Website Route,nadřazená cesta internetové stránky
-DocType: Sales Order,Not Billed,Ne Účtovaný
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +107,Both Warehouse must belong to same Company,Oba Sklady musí patřit do stejné společnosti
-sites/assets/js/erpnext.min.js +20,No contacts added yet.,Žádné kontakty přidán dosud.
-apps/frappe/frappe/workflow/doctype/workflow/workflow_list.js +7,Not active,Neaktivní
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +43,Against Invoice Posting Date,Proti faktury Datum zveřejnění
-DocType: Purchase Receipt Item,Landed Cost Voucher Amount,Přistál Náklady Voucher Částka
-DocType: Time Log,Batched for Billing,Zarazeno pro fakturaci
-apps/erpnext/erpnext/config/accounts.py +23,Bills raised by Suppliers.,Směnky vznesené dodavately
-DocType: POS Setting,Write Off Account,Odepsat účet
-DocType: Purchase Invoice,Discount Amount,Částka slevy
-DocType: Item,Warranty Period (in days),Záruční doba (ve dnech)
-DocType: Email Digest,Expenses booked for the digest period,Náklady rezervované pro období digest
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +500,e.g. VAT,např. DPH
-DocType: Journal Entry Account,Journal Entry Account,Zápis do deníku Účet
-DocType: Shopping Cart Settings,Quotation Series,Číselná řada nabídek
-apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +51,"An item exists with same name ({0}), please change the item group name or rename the item","Položka existuje se stejným názvem ({0}), prosím, změnit název skupiny položky nebo přejmenovat položku"
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +81,Hot metal gas forming,Tváření Hot metal plyn
-DocType: Sales Order Item,Sales Order Date,Prodejní objednávky Datum
-DocType: Sales Invoice Item,Delivered Qty,Dodává Množství
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +63,Warehouse {0}: Company is mandatory,Sklad {0}: Společnost je povinná
-DocType: Item,Percentage variation in quantity to be allowed while receiving or delivering this item.,"Procentuální změna v množství, aby mohla při přijímání nebo poskytování této položky."
-DocType: Shopping Cart Taxes and Charges Master,Shopping Cart Taxes and Charges Master,Nákupní košík daně a poplatky Mistr
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +36,"Go to the appropriate group (usually Source of Funds > Current Liabilities > Taxes and Duties and create a new Account (by clicking on Add Child) of type ""Tax"" and do mention the Tax rate.",Přejděte na příslušné skupiny (obvykle zdrojem finančních prostředků&gt; krátkodobých závazků&gt; daní a poplatků a vytvořit nový účet (kliknutím na Přidat dítě) typu &quot;daně&quot; a to nemluvím o daňovou sazbu.
-,Payment Period Based On Invoice Date,Platební období na základě data vystavení faktury
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +113,Missing Currency Exchange Rates for {0},Chybí Směnárna Kurzy pro {0}
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +134,Laser cutting,Laserové řezání
-DocType: Event,Monday,Pondělí
-DocType: Journal Entry,Stock Entry,Reklamní Entry
-DocType: Account,Payable,Splatný
-DocType: Salary Slip,Arrear Amount,Nedoplatek Částka
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Noví zákazníci
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +68,Gross Profit %,Hrubý Zisk %
-DocType: Appraisal Goal,Weightage (%),Weightage (%)
-DocType: Bank Reconciliation Detail,Clearance Date,Výprodej Datum
-DocType: Newsletter,Newsletter List,Newsletter Seznam
-DocType: Salary Manager,Check if you want to send salary slip in mail to each employee while submitting salary slip,"Zkontrolujte, zda chcete poslat výplatní pásku za poštou na každého zaměstnance při předkládání výplatní pásku"
-DocType: Lead,Address Desc,Popis adresy
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +33,Atleast one of the Selling or Buying must be selected,Aspoň jeden z prodeje nebo koupě musí být zvolena
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230,"Difference Account must be a 'Liability' type account, since this Stock Reconciliation is an Opening Entry","Rozdíl účet musí být ""Odpovědnost"" typ účtu, protože tento Reklamní Usmíření je Entry Otevření"
-apps/erpnext/erpnext/stock/doctype/item/item.js +215,"Variants can not be created manually, add item attributes in the template item","Varianty nelze vytvořit ručně, přidejte atributy položku v položce šablony"
-apps/erpnext/erpnext/config/manufacturing.py +34,Where manufacturing operations are carried.,"Tam, kde jsou výrobní operace prováděny."
-DocType: Page,All,Vše
-DocType: Stock Entry Detail,Source Warehouse,Zdroj Warehouse
-DocType: Installation Note,Installation Date,Datum instalace
-DocType: Employee,Confirmation Date,Potvrzení Datum
-DocType: C-Form,Total Invoiced Amount,Celkem Fakturovaná částka
-DocType: Communication,Sales User,Uživatel prodeje
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +46,Min Qty can not be greater than Max Qty,Min množství nemůže být větší než Max Množství
-apps/frappe/frappe/core/page/permission_manager/permission_manager.js +421,Set,Nastavit
-DocType: Item,Warehouse-wise Reorder Levels,Změna Úrovně dle skladu
-DocType: Lead,Lead Owner,Olovo Majitel
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +241,Warehouse is required,Je zapotřebí Warehouse
-DocType: Employee,Marital Status,Rodinný stav
-DocType: Stock Settings,Auto Material Request,Auto materiálu Poptávka
-DocType: Time Log,Will be updated when billed.,Bude aktualizována při účtovány.
-apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +25,Current BOM and New BOM can not be same,Aktuální BOM a New BOM nemůže být stejné
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +107,Date Of Retirement must be greater than Date of Joining,"Datum odchodu do důchodu, musí být větší než Datum spojování"
-DocType: Sales Invoice,Against Income Account,Proti účet příjmů
-apps/erpnext/erpnext/controllers/website_list_for_contact.py +52,{0}% Delivered,{0}% vyhlášeno
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +82,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Položka {0}: Objednané množství {1} nemůže být nižší než minimální Objednané množství {2} (definované v bodu).
-DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Měsíční Distribution Procento
-DocType: Territory,Territory Targets,Území Cíle
-DocType: Delivery Note,Transporter Info,Transporter Info
-DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Dodané položky vydané objednávky
-apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Dopis hlavy na tiskových šablon.
-apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,"Tituly na tiskových šablon, např zálohové faktury."
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +140,Valuation type charges can not marked as Inclusive,Poplatky typu ocenění může není označen jako Inclusive
-DocType: POS Setting,Update Stock,Aktualizace skladem
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +127,Superfinishing,Superfinišování
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100,Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,"Různé UOM položky povede k nesprávné (celkem) Čistá hmotnost hodnoty. Ujistěte se, že čistá hmotnost každé položky je ve stejném nerozpuštěných."
-apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,BOM Rate
-DocType: Shopping Cart Settings,"<a href=""#Sales Browser/Territory"">Add / Edit</a>","<a href=""#Sales Browser/Territory""> Přidat / Upravit </a>"
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +94,Please pull items from Delivery Note,"Prosím, vytáhněte položky z dodací list"
-apps/erpnext/erpnext/accounts/utils.py +235,Journal Entries {0} are un-linked,Zápisů {0} jsou un-spojený
-DocType: Purchase Invoice,Terms,Podmínky
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +235,Create New,Vytvořit nový
-DocType: Buying Settings,Purchase Order Required,Vydaná objednávka je vyžadována
-,Item-wise Sales History,Item-moudrý Sales History
-DocType: Expense Claim,Total Sanctioned Amount,Celková částka potrestána
-,Purchase Analytics,Nákup Analytika
-DocType: Sales Invoice Item,Delivery Note Item,Delivery Note Item
-DocType: Expense Claim,Task,Úkol
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +56,Shaving,Holení
-DocType: Purchase Taxes and Charges,Reference Row #,Referenční Row #
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +67,Batch number is mandatory for Item {0},Číslo šarže je povinné pro položku {0}
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +14,This is a root sales person and cannot be edited.,To je kořen prodejní člověk a nelze upravovat.
-,Stock Ledger,Reklamní Ledger
-DocType: Salary Slip Deduction,Salary Slip Deduction,Plat Slip Odpočet
-apps/erpnext/erpnext/stock/doctype/item/item.py +368,"To set reorder level, item must be a Purchase Item","Chcete-li nastavit úroveň Objednací, položka musí být Nákup položky"
-apps/frappe/frappe/desk/doctype/note/note_list.js +3,Notes,Poznámky
-DocType: Opportunity,From,Od
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +192,Select a group node first.,Vyberte první uzel skupinu.
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +88,Purpose must be one of {0},Cíl musí být jedním z {0}
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +101,Fill the form and save it,Vyplňte formulář a uložte jej
-DocType: Production Planning Tool,Download a report containing all raw materials with their latest inventory status,"Stáhněte si zprávu, která obsahuje všechny suroviny s jejich aktuální stav zásob"
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +93,Facing,Obložení
-DocType: Leave Application,Leave Balance Before Application,Nechte zůstatek před aplikací
-DocType: SMS Center,Send SMS,Pošlete SMS
-DocType: Company,Default Letter Head,Výchozí hlavičkový
-DocType: Time Log,Billable,Zúčtovatelná
-DocType: Authorization Rule,This will be used for setting rule in HR module,Tato adresa bude použita pro nastavení pravidlo HR modul
-DocType: Account,Rate at which this tax is applied,"Rychlost, při které se používá tato daň"
-apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +34,Reorder Qty,Změna pořadí Množství
-DocType: Company,Stock Adjustment Account,Reklamní Nastavení účtu
-DocType: Sales Invoice,Write Off,Odepsat
-DocType: Time Log,Operation ID,Provoz ID
-DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","System User (login) ID. Pokud je nastaveno, stane se výchozí pro všechny formy HR."
-apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}: Z {1}
-DocType: Task,depends_on,záleží na
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +81,Opportunity Lost,Příležitost Ztracena
-DocType: Features Setup,"Discount Fields will be available in Purchase Order, Purchase Receipt, Purchase Invoice","Sleva Pole bude k dispozici v objednávce, doklad o koupi, nákupní faktury"
-DocType: Report,Report Type,Typ výpisu
-apps/frappe/frappe/core/doctype/user/user.js +136,Loading,Nahrávám
-DocType: BOM Replace Tool,BOM Replace Tool,BOM Nahradit Tool
-apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Země moudrý výchozí adresa Templates
-apps/erpnext/erpnext/accounts/party.py +196,Due / Reference Date cannot be after {0},Vzhledem / Referenční datum nemůže být po {0}
-DocType: Features Setup,If you involve in manufacturing activity. Enables Item 'Is Manufactured',"Pokud se zapojit do výrobní činnosti. Umožňuje Položka ""se vyrábí"""
-DocType: Sales Invoice,Rounded Total,Zaoblený Total
-DocType: Sales BOM,List items that form the package.,"Seznam položek, které tvoří balíček."
-apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Podíl alokace by měla být ve výši 100%
-DocType: Serial No,Out of AMC,Out of AMC
-DocType: Purchase Order Item,Material Request Detail No,Materiál Poptávka Detail No
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +96,Hard turning,Hard soustružení
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.js +33,Make Maintenance Visit,Proveďte návštěv údržby
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +165,Please contact to the user who have Sales Master Manager {0} role,"Prosím, kontaktujte pro uživatele, kteří mají obchodní manažer ve skupině Master {0} roli"
-DocType: Company,Default Cash Account,Výchozí Peněžní účet
-apps/erpnext/erpnext/config/setup.py +91,Company (not Customer or Supplier) master.,Company (nikoliv zákazník nebo dodavatel) master.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +68,Please enter 'Expected Delivery Date',"Prosím, zadejte ""Očekávaná Datum dodání"""
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +492,"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.","Seznam své daňové hlavy (např DPH, spotřební daň, měli by mít jedinečné názvy) a jejich standardní sazby. Tím se vytvoří standardní šablonu, kterou si můžete upravit a přidat další později."
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +168,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Dodací listy {0} musí být zrušena před zrušením této prodejní objednávky
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +323,Paid amount + Write Off Amount can not be greater than Grand Total,Placená částka + odepsat Částka nesmí být větší než Grand Total
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +69,{0} is not a valid Batch Number for Item {1},{0} není platná Šarže pro Položku {1}
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +109,Note: There is not enough leave balance for Leave Type {0},Poznámka: Není k dispozici dostatek zůstatek dovolené dovolená za kalendářní typ {0}
-apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +9,"Note: If payment is not made against any reference, make Journal Entry manually.","Poznámka: Není-li platba provedena proti jakémukoli rozhodnutí, jak položka deníku ručně."
-DocType: Item,Supplier Items,Dodavatele položky
-apps/erpnext/erpnext/stock/doctype/item/item.py +165,Please enter atleast one attribute row in Item Variants table,Zadejte prosím aspoň jeden atribut řádek položky Varianty tabulku
-DocType: Opportunity,Opportunity Type,Typ Příležitosti
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +42,New Company,Nová společnost
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +50,Cost Center is required for 'Profit and Loss' account {0},"Nákladové středisko je vyžadováno pro účet ""výkaz zisku a ztrát"" {0}"
-apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +16,Transactions can only be deleted by the creator of the Company,Transakce mohou být vymazány pouze tvůrce Společnosti
-apps/erpnext/erpnext/accounts/general_ledger.py +21,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Nesprávný počet hlavní knihy záznamů nalezen. Pravděpodobně jste zvolili nesprávný účet v transakci.
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +31,To create a Bank Account,Chcete-li vytvořit si účet v bance
-DocType: Hub Settings,Publish Availability,Publikování Dostupnost
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +101,Date of Birth cannot be greater than today.,Datum narození nemůže být větší než dnes.
-,Stock Ageing,Reklamní Stárnutí
-DocType: Purchase Receipt,Automatically updated from BOM table,Automaticky aktualizována z BOM tabulky
-apps/erpnext/erpnext/controllers/accounts_controller.py +170,{0} '{1}' is disabled, {0} '{1}' je zakázána
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Nastavit jako Otevřít
-DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Posílat automatické e-maily na Kontakty na předložení transakcí.
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +282,"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.
+Leave Type,Leave Type,
+Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Náklady / Rozdíl účtu ({0}), musí být ""zisk nebo ztráta"" účet"
+Accounts User,Uživatel Účt$1,
+"Check if recurring invoice, uncheck to stop recurring or put proper End Date","Zkontrolujte, zda je opakující se faktury, zrušte zaškrtnutí zastavit opakované nebo dát správné datum ukončení"
+Attendance for employee {0} is already marked,Účast na zaměstnance {0} je již označen,
+If more than one package of the same type (for print),Pokud je více než jeden balík stejného typu (pro tisk)
+Maximum {0} rows allowed,Maximálně {0} řádků povoleno,
+Net Total,Net Total,
+FCFS Rate,FCFS Rate,
+Billing (Sales Invoice),Fakturace (Prodejní Faktura)
+Outstanding Amount,Dlužné částky,
+Working,Pracovny,
+Stock Queue (FIFO),Sklad fronty (FIFO)
+Please select Time Logs.,Vyberte Time Protokoly.
+{0} does not belong to Company {1},{0} nepatří do Společnosti {1}
+Requested Qty,Požadované množstv$1,
+Scrap %,Scrap%
+"Charges will be distributed proportionately based on item qty or amount, as per your selection","Poplatky budou rozděleny úměrně na základě položky Množství nebo částkou, dle Vašeho výběru"
+Purposes,Cíle,
+"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Provoz {0} déle, než všech dostupných pracovních hodin v pracovní stanici {1}, rozložit provoz do několika operací"
+Electrochemical machining,Elektrochemické obráběny,
+Requested,Požadovany,
+No Remarks,Žádné poznámky,
+Overdue,Zpožděny,
+Stock Received But Not Billed,Sklad nepřijali Účtovany,
+Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,Gross Pay + nedoplatek Částka + Inkaso Částka - Total Odpočet,
+Distribution Name,Distribuce Name,
+Sales and Purchase,Prodej a nákup,
+Price / Discount,Cena / Sleva,
+Material Request No,Materiál Poptávka No,
+Quality Inspection required for Item {0},Kontrola kvality potřebný k bodu {0}
+Rate at which customer's currency is converted to company's base currency,"Sazba, za kterou zákazník měny je převeden na společnosti základní měny"
+Discount Amount (Company Currency),Částka slevy (Company Měna)
+{0} has been successfully unsubscribed from this list.,{0} byl úspěšně odhlášen z tohoto seznamu.
+Net Rate (Company Currency),Čistý Rate (Company měny)
+Manage Territory Tree.,Správa Territory strom.
+Sales Invoice,Prodejní faktury,
+Party Balance,Balance Party,
+Time Log Batch,Time Log Batch,
+Please select Apply Discount On,"Prosím, vyberte Použít Sleva na"
+Default Receivable Account,Výchozí pohledávek účtu,
+Create Bank Entry for the total salary paid for the above selected criteria,Vytvoření bankovní položka pro celkové vyplacené mzdy za výše zvolených kritériu,
+Item will be saved by this name in the data base.,Bod budou uloženy pod tímto jménem v databázi.
+Material Transfer for Manufacture,Materiál Přenos: Výroba,
+Discount Percentage can be applied either against a Price List or for all Price List.,Sleva v procentech lze použít buď proti Ceníku nebo pro všechny Ceníku.
+Half-yearly,Pololetn$1,
+Fiscal Year {0} not found.,Fiskální rok {0} nebyl nalezen.
+Get Relevant Entries,Získat příslušné zápisy,
+Accounting Entry for Stock,Účetní položka na sklady,
+Coining,Raženy,
+Sales Team1,Sales Team1,
+Item {0} does not exist,Bod {0} neexistuje,
+"Selecting ""Yes"" will allow you to make a Production Order for this item.","Výběrem ""Yes"" vám umožní, aby se výrobní zakázku pro tuto položku."
+Customer Address,Zákazník Address,
+Total,Celkem,
+System for managing Backups,Systém pro správu zálohováns,
+Root Type,Root Type,
+Plot,Spiknuts,
+Show this slideshow at the top of the page,Zobrazit tuto prezentaci v horní části stránky,
+Item UOM,Položka UOM,
+Tax Amount After Discount Amount (Company Currency),Částka daně po slevě Částka (Company měny)
+Target warehouse is mandatory for row {0},Target sklad je povinná pro řadu {0}
+Quality Inspection,Kontrola kvality,
+Extra Small,Extra Maly,
+Spray forming,Spray tvářeny,
+Warning: Material Requested Qty is less than Minimum Order Qty,Upozornění: Materiál Požadované množství je menší než minimální objednávka Množstvy,
+Account {0} is frozen,Účet {0} je zmrazen,
+Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,"Právní subjekt / dceřiná společnost s oddělenou Graf účtů, které patří do organizace."
+Address master.,Adresa master.
+"Food, Beverage & Tobacco","Potraviny, nápoje a tabák"
+PL or BS,PL nebo BS,
+Commission rate cannot be greater than 100,Rychlost Komise nemůže být větší než 100,
+Minimum Inventory Level,Minimální úroveň zásob,
+Subcontract,Subdodávka,
+Get Items From Sales Orders,Získat položky z Prodejní Objednávky,
+Actual End Time,Aktuální End Time,
+Download Materials Required,Ke stažení potřebné materiály:
+Manufacturer Part Number,Typové označeny,
+Estimated Time and Cost,Odhadovná doba a náklady,
+Bin,Popelnice,
+Nosing,Zaoblená hrana,
+No of Sent SMS,Počet odeslaných SMS,
+Company,Společnost,
+Expense Account,Účtet náklady,
+Software,Software,
+Colour,Barevny,
+Scheduled,Plánovany,
+Select Monthly Distribution to unevenly distribute targets across months.,Vyberte měsíční výplatou na nerovnoměrně distribuovat cílů napříč měsíců.
+Valuation Rate,Ocenění Rate,
+Check to make Shipping Address,Zaškrtněte pro vytvoření doručovací adresy,
+Price List Currency not selected,Ceníková Měna není zvolena,
+Item Row {0}: Purchase Receipt {1} does not exist in above 'Purchase Receipts' table,"Bod Row {0}: doklad o koupi, {1} neexistuje v tabulce ""kupní příjmy"""
+Applicability,Použitelnost,
+Employee {0} has already applied for {1} between {2} and {3},Zaměstnanec {0} již požádal o {1} mezi {2} a {3}
+Project Start Date,Datum zahájení projektu,
+Until,Dokud,
+Rename Log,Přejmenovat Přihlásit,
+Against Document No,Proti dokumentu u,
+Manage Sales Partners.,Správa prodejních partnerů.
+Inspection Type,Kontrola Type,
+Please select {0},"Prosím, vyberte {0}"
+C-Form No,C-Form No,
+Exploded_items,Exploded_items,
+Researcher,Výzkumník,
+Update,Aktualizovat,
+Please save the Newsletter before sending,Uložte Newsletter před odesláním,
+Name or Email is mandatory,Jméno nebo e-mail je povinno,
+Incoming quality inspection.,Vstupní kontrola jakosti.
+Exit,Východ,
+Root Type is mandatory,Root Type je povinnd,
+Serial No {0} created,Pořadové číslo {0} vytvořil,
+Vibratory finishing,Vibrační dokončovacd,
+"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Pro pohodlí zákazníků, tyto kódy mohou být použity v tiskových formátech, jako na fakturách a dodacích listech"
+Against Purchase Order,Proti vydané objednávce,
+You can enter any date manually,Můžete zadat datum ručne,
+Advertisement,Reklama,
+Probationary Period,Zkušební doba,
+Only leaf nodes are allowed in transaction,Pouze koncové uzly jsou povoleny v transakci,
+Expense Approver,Schvalovatel výdaje,
+Purchase Receipt Item Supplied,Doklad o koupi Item Dodávane,
+Pay,Platit,
+To Datetime,Chcete-li datetime,
+SMS Gateway URL,SMS brána URL,
+Grinding,Broušene,
+Shrink wrapping,Zmenšit balene,
+Supplier > Supplier Type,Dodavatel> Dodavatel Type,
+Please enter relieving date.,Zadejte zmírnění datum.
+Amt,Amt,
+Serial No {0} status must be 'Available' to Deliver,"Pořadové číslo {0} status musí být ""k dispozici"" doručovat"
+Only Leave Applications with status 'Approved' can be submitted,"Nechte pouze aplikace s status ""schváleno"" může být předloženy"
+Address Title is mandatory.,Adresa Název je povinný.
+Enter name of campaign if source of enquiry is campaign,"Zadejte název kampaně, pokud zdroj šetření je kampaň"
+Newspaper Publishers,Vydavatelé novin,
+Select Fiscal Year,Vyberte Fiskální rok,
+Smelting,Tavba rudy,
+You are the Leave Approver for this record. Please Update the 'Status' and Save,"Jste Leave schvalujícím pro tento záznam. Prosím aktualizujte ""stavu"" a Uložit"
+Reorder Level,Změna pořadí Level,
+Attendance Date,Účast Datum,
+Salary breakup based on Earning and Deduction.,Plat rozpad na základě Zisk a dedukce.
+Account with child nodes cannot be converted to ledger,Účet s podřízenými uzly nelze převést na hlavní účetní knihu,
+Preferred Shipping Address,Preferovaná dodací adresa,
+Accepted Warehouse,Schválené Sklad,
+Posting Date,Datum zveřejněnu,
+Valuation Method,Ocenění Method,
+Sales Team,Prodejní tým,
+Duplicate entry,Duplicitní záznam,
+Under Warranty,V rámci záruky,
+[Error],[Chyba]
+In Words will be visible once you save the Sales Order.,"Ve slovech budou viditelné, jakmile uložíte prodejní objednávky."
+Employee Birthday,Narozeniny zaměstnance,
+Debit Amt,Debetní Amt,
+Venture Capital,Venture Capital,
+Must be Whole Number,Musí být celé číslo,
+New Leaves Allocated (In Days),Nové Listy Přidělené (ve dnech)
+Serial No {0} does not exist,Pořadové číslo {0} neexistuje,
+Discount Percentage,Sleva v procentech,
+Invoice Number,Číslo faktury,
+Orders,Objednávky,
+Employee Type,Type zaměstnance,
+Leave Approver,Nechte schvalovae,
+Swaging,Zužováne,
+"A user with ""Expense Approver"" role","Uživatel s rolí ""Schvalovatel výdajů"""
+Issued Items Against Production Order,Vydané předmětů proti výrobní zakázky,
+Purchase Manager,Vedoucí nákupu,
+Payment Tool,Platebního nástroje,
+Target Detail,Target Detail,
+% of materials billed against this Sales Order,% Materiálů fakturovaných proti tomuto odběrateli,
+Period Closing Entry,Období Uzávěrka Entry,
+Cost Center with existing transactions can not be converted to group,Nákladové středisko se stávajícími transakcemi nelze převést do skupiny,
+Depreciation,Znehodnoceny,
+Supplier(s),Dodavatel (é)
+Payments received during the digest period,Platby přijaté během období digest,
+Credit Limit,Úvěrový limit,
+To enable <b>Point of Sale</b> features,Chcete-li povolit <b> Point of Sale </ b> funkce,
+LR Date,LR Datum,
+Select type of transaction,Vyberte typ transakce,
+Voucher No,Voucher No,
+Leave Allocation,Nechte Allocation,
+'Update Stock' for Sales Invoice {0} must be set,"Musí být nastavena ""Aktualizace Skladu"" pro prodejní faktury {0}"
+Material Requests {0} created,Materiál Žádosti {0} vytvořen$1,
+Template of terms or contract.,Šablona podmínek nebo smlouvy.
+Feedback,Zpětná vazba,
+Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Poznámka: Z důvodu / Referenční datum překračuje povolené zákazníků úvěrové dní od {0} den (s)
+Abrasive jet machining,Brusné jet obráběny,
+Freeze Stock Entries,Freeze Stock Příspěvky,
+Website Settings,Nastavení www stránky,
+Billing Rate,Fakturace Rate,
+Qty to Deliver,Množství k dodány,
+Month,Měsíc,
+Stock Analytics,Stock Analytics,
+Against Document Detail No,Proti Detail dokumentu y,
+Outgoing,Vycházejícy,
+Requested For,Požadovaných pro,
+Against Doctype,Proti DOCTYPE,
+Track this Delivery Note against any Project,Sledovat tento dodacím listu proti jakémukoli projektu,
+Root account can not be deleted,Root účet nemůže být smazán,
+Credit Amt,Credit Amt,
+Show Stock Entries,Zobrazit Stock Příspěvky,
+Work-in-Progress Warehouse,Work-in-Progress sklad,
+Reference #{0} dated {1},Reference # {0} ze dne {1}
+Item Code,Kód položky,
+Material Manager,Materiál Správce,
+Create Production Orders,Vytvoření výrobní zakázky,
+Costing Rate (per hour),Kalkulace Rate (za hodinu)
+Warranty / AMC Details,Záruka / AMC Podrobnosti,
+User Remark,Uživatel Poznámka,
+Point-of-Sale Setting,Nastavení Místa Prodeje,
+Market Segment,Segment trhu,
+Phone,Telefon,
+Supplier (Payable) Account,Dodavatel (za poplatek) Account,
+Employee Internal Work History,Interní historie práce zaměstnance,
+Closing (Dr),Uzavření (Dr)
+Passive,Pasivnm,
+Serial No {0} not in stock,Pořadové číslo {0} není skladem,
+Tax template for selling transactions.,Daňové šablona na prodej transakce.
+Write Off Outstanding Amount,Odepsat dlužné částky,
+"Check if you need automatic recurring invoices. After submitting any sales invoice, Recurring section will be visible.","Zkontrolujte, zda potřebujete automatické opakující faktury. Po odeslání jakékoliv prodejní fakturu, opakující se část bude viditelný."
+Accounts Manager,Accounts Manager,
+Time Log {0} must be 'Submitted',"Time Log {0} musí být ""Odesláno"""
+Default Stock UOM,Výchozí Skladem UOM,
+Create Material Requests,Vytvořit Žádosti materiálu,
+School/University,Škola / University,
+Available Qty at Warehouse,Množství k dispozici na skladu,
+Billed Amount,Fakturovaná částka,
+Bank Reconciliation,Bank OdsouhlasenM,
+Total Amount To Pay,Celková částka k Zaplatit,
+Material Request {0} is cancelled or stopped,Materiál Request {0} je zrušena nebo zastavena,
+Groups,Skupiny,
+Group by Account,Seskupit podle účtu,
+Fully Delivered,Plně Dodáno,
+Lower Income,S nižšími příjmy,
+"The account head under Liability, in which Profit/Loss will be booked","Účet hlavu pod odpovědnosti, ve kterém se bude Zisk / ztráta rezervovali"
+Against Vouchers,Proti Poukázky,
+Quick Help,Rychlá pomoc,
+Source and target warehouse cannot be same for row {0},Zdroj a cíl sklad nemůže být stejná pro řádek {0}
+Sales Extras,Prodejní Extras,
+{0} budget for Account {1} against Cost Center {2} will exceed by {3},{0} rozpočt na účet {1} proti nákladovému středisku {2} bude vyšší o {3}
+Purchase Order number required for Item {0},Číslo vydané objednávky je potřebné k položce {0}
+Carry Forwarded Leaves,Carry Předáno listy,
+'From Date' must be after 'To Date',"""Datum DO"" musí být po ""Datum OD"""
+Stock Projected Qty,Reklamní Plánovaná POČET,
+Customer {0} does not belong to project {1},Zákazník {0} nepatří k projektu {1}
+From Company,Od Společnosti,
+Value or Qty,Hodnota nebo Množstvi,
+Minute,Minuta,
+Purchase Taxes and Charges,Nákup Daně a poplatky,
+Upload Backups to Dropbox,Nahrát zálohy na Dropbox,
+Qty to Receive,Množství pro příjem,
+Leave Block List Allowed,Nechte Block List povolena,
+Conversion factor cannot be in fractions,Konverzní faktor nemůže být ve zlomcích,
+You will use it to Login,Budete ho používat k přihlášeni,
+Retailer,Maloobchodník,
+All Supplier Types,Všechny typy Dodavatele,
+Item Code is mandatory because Item is not automatically numbered,"Kód položky je povinné, protože položka není automaticky číslovány"
+Quotation {0} not of type {1},Nabídka {0} není typu {1}
+Maintenance Schedule Item,Plán údržby Item,
+%  Delivered,% Dodáno,
+Bank Overdraft Account,Kontokorentní úvěr na účtu,
+Make Salary Slip,Proveďte výplatní pásce,
+Unstop,Uvolnit,
+Secured Loans,Zajištěné úvěry,
+Ignored:,Ignorovat: 
+{0} cannot be purchased using Shopping Cart,{0} není možné zakoupit pomocí Nákupní košík,
+Awesome Products,Skvělé produkty,
+Opening Balance Equity,Počáteční stav Equity,
+Cannot approve leave as you are not authorized to approve leaves on Block Dates,Nelze schválit dovolenou si nejste oprávněna schvalovat listy na blok Termíny,
+Appraisal,Oceněnk,
+Lost-foam casting,Lost-pěna litk,
+Drawing,Výkres,
+Date is repeated,Datum se opakuje,
+Leave approver must be one of {0},Nechte Schvalující musí být jedním z {0}
+Seller Email,Prodávající E-mail,
+Total Purchase Cost (via Purchase Invoice),Celkové pořizovací náklady (přes nákupní faktury)
+Start Time,Start Time,
+Select Quantity,Zvolte množstve,
+"Specify a list of Territories, for which, this Taxes Master is valid","Zadejte seznam území, pro které tato Daně Master je platný"
+Approving Role cannot be same as role the rule is Applicable To,Schválení role nemůže být stejná jako role pravidlo se vztahuje na,
+Message Sent,Zpráva byla odeslána,
+SO Date,SO Datum,
+Rate at which Price list currency is converted to customer's base currency,"Sazba, za kterou Ceník měna je převeden na zákazníka základní měny"
+Net Amount (Company Currency),Čistá částka (Company Měna)
+Hour Rate,Hour Rate,
+Item Naming By,Položka Pojmenování By,
+From Quotation,Z nabídky,
+Another Period Closing Entry {0} has been made after {1},Další období Uzávěrka Entry {0} byla podána po {1}
+Material Transferred for Manufacturing,Materiál Přenesená pro výrobu,
+Account {0} does not exists,Účet {0} neexistuje,
+Purchase Order Item No,Číslo položky vydané objednávky,
+System Settings,Nastavení systému,
+Project Type,Typ projektu,
+Either target qty or target amount is mandatory.,Buď cílové množství nebo cílová částka je povinná.
+Cost of various activities,Náklady na různých aktivit,
+Not allowed to update stock transactions older than {0},Není dovoleno měnit obchodů s akciemi starší než {0}
+Inspection Required,Kontrola Povinnl,
+PR Detail,PR Detail,
+Fully Billed,Plně Fakturovanl,
+Cash In Hand,Pokladní hotovost,
+The gross weight of the package. Usually net weight + packaging material weight. (for print),Celková hmotnost balení. Obvykle se čistá hmotnost + obalového materiálu hmotnosti. (Pro tisk)
+Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Uživatelé s touto rolí se mohou nastavit na zmrazené účty a vytvořit / upravit účetní zápisy proti zmrazených účto,
+Is Cancelled,Je Zrušeno,
+My Shipments,Moje dodávky,
+Bill Date,Bill Datum,
+"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","I když existuje více pravidla pro tvorbu cen s nejvyšší prioritou, pak následující interní priority jsou použity:"
+Supplier Details,Dodavatele Podrobnosti,
+Recipients,Příjemci,
+Screwing,Šroubováni,
+Knurling,Vroubkováni,
+Approval Status,Stav schváleni,
+Publish Items to Hub,Publikování položky do Hub,
+From value must be less than to value in row {0},Z hodnota musí být menší než hodnota v řadě {0}
+Wire Transfer,Bankovní převod,
+Please select Bank Account,"Prosím, vyberte bankovní účet"
+Create and Send Newsletters,Vytvoření a odeslání Zpravodaje,
+From Date must be before To Date,Datum od musí být dříve než datum do,
+Recurring Order,Opakující se objednávky,
+Default Income Account,Účet Default příjme,
+Customer Group / Customer,Zákazník Group / Customer,
+Check this if you want to show in website,"Zaškrtněte, pokud chcete zobrazit v webové stránky"
+Welcome to ERPNext,Vítejte na ERPNext,
+Voucher Detail Number,Voucher Detail Počet,
+From Customer,Od Zákazníka,
+Calls,Volt,
+Total Costing Amount (via Time Logs),Celková kalkulace Částka (přes Time Záznamy)
+Stock UOM,Reklamní UOM,
+Purchase Order {0} is not submitted,Vydaná objednávka {0} není odeslána,
+{0} {1} is entered more than once in Item Variants table,{0} {1} je vloženo více než jednou v  tabulce Varianty  Položky,
+Projected,PlánovanM,
+Serial No {0} does not belong to Warehouse {1},Pořadové číslo {0} nepatří do skladu {1}
+Note: Reference Date exceeds allowed credit days by {0} days for {1} {2},Poznámka: Odkaz Datum překračuje povolené úvěrové dnů od {0} dní na {1} {2}
+Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Poznámka: Systém nebude kontrolovat přes dobírku a over-rezervace pro item {0} jako množství nebo částka je 0,
+Quotation Message,Zpráva Nabídky,
+Opening Date,Datum otevřen0,
+POS Setting {0} already created for user: {1} and company {2},POS nastavení {0} již vytvořili pro uživatele: {1} a společnost {2}
+Remark,Poznámka,
+Rate and Amount,Tempo a rozsah,
+Boring,Nudna,
+From Sales Order,Z přijaté objednávky,
+Parent Website Route,nadřazená cesta internetové stránky,
+Not Billed,Ne Účtovana,
+Both Warehouse must belong to same Company,Oba Sklady musí patřit do stejné společnosti,
+No contacts added yet.,Žádné kontakty přidán dosud.
+Not active,Neaktivna,
+Against Invoice Posting Date,Proti faktury Datum zveřejněna,
+Landed Cost Voucher Amount,Přistál Náklady Voucher Částka,
+Batched for Billing,Zarazeno pro fakturaci,
+Bills raised by Suppliers.,Směnky vznesené dodavately,
+Write Off Account,Odepsat účet,
+Discount Amount,Částka slevy,
+Warranty Period (in days),Záruční doba (ve dnech)
+Expenses booked for the digest period,Náklady rezervované pro období digest,
+e.g. VAT,např. DPH,
+Journal Entry Account,Zápis do deníku Účet,
+Quotation Series,Číselná řada nabídek,
+"An item exists with same name ({0}), please change the item group name or rename the item","Položka existuje se stejným názvem ({0}), prosím, změnit název skupiny položky nebo přejmenovat položku"
+Hot metal gas forming,Tváření Hot metal plyn,
+Sales Order Date,Prodejní objednávky Datum,
+Delivered Qty,Dodává Množstvn,
+Warehouse {0}: Company is mandatory,Sklad {0}: Společnost je povinnn,
+Percentage variation in quantity to be allowed while receiving or delivering this item.,"Procentuální změna v množství, aby mohla při přijímání nebo poskytování této položky."
+Shopping Cart Taxes and Charges Master,Nákupní košík daně a poplatky Mistr,
+"Go to the appropriate group (usually Source of Funds > Current Liabilities > Taxes and Duties and create a new Account (by clicking on Add Child) of type ""Tax"" and do mention the Tax rate.",Přejděte na příslušné skupiny (obvykle zdrojem finančních prostředků&gt; krátkodobých závazků&gt; daní a poplatků a vytvořit nový účet (kliknutím na Přidat dítě) typu &quot;daně&quot; a to nemluvím o daňovou sazbu.
+Payment Period Based On Invoice Date,Platební období na základě data vystavení faktury,
+Missing Currency Exchange Rates for {0},Chybí Směnárna Kurzy pro {0}
+Laser cutting,Laserové řezány,
+Monday,Ponděly,
+Stock Entry,Reklamní Entry,
+Payable,Splatny,
+Arrear Amount,Nedoplatek Částka,
+New Customers,Noví zákazníci,
+Gross Profit %,Hrubý Zisk %
+Weightage (%),Weightage (%)
+Clearance Date,Výprodej Datum,
+Newsletter List,Newsletter Seznam,
+Check if you want to send salary slip in mail to each employee while submitting salary slip,"Zkontrolujte, zda chcete poslat výplatní pásku za poštou na každého zaměstnance při předkládání výplatní pásku"
+Address Desc,Popis adresy,
+Atleast one of the Selling or Buying must be selected,Aspoň jeden z prodeje nebo koupě musí být zvolena,
+"Difference Account must be a 'Liability' type account, since this Stock Reconciliation is an Opening Entry","Rozdíl účet musí být ""Odpovědnost"" typ účtu, protože tento Reklamní Usmíření je Entry Otevření"
+"Variants can not be created manually, add item attributes in the template item","Varianty nelze vytvořit ručně, přidejte atributy položku v položce šablony"
+Where manufacturing operations are carried.,"Tam, kde jsou výrobní operace prováděny."
+All,Vše,
+Source Warehouse,Zdroj Warehouse,
+Installation Date,Datum instalace,
+Confirmation Date,Potvrzení Datum,
+Total Invoiced Amount,Celkem Fakturovaná částka,
+Sales User,Uživatel prodeje,
+Min Qty can not be greater than Max Qty,Min množství nemůže být větší než Max Množstve,
+Set,Nastavit,
+Warehouse-wise Reorder Levels,Změna Úrovně dle skladu,
+Lead Owner,Olovo Majitel,
+Warehouse is required,Je zapotřebí Warehouse,
+Marital Status,Rodinný stav,
+Auto Material Request,Auto materiálu Poptávka,
+Will be updated when billed.,Bude aktualizována při účtovány.
+Current BOM and New BOM can not be same,Aktuální BOM a New BOM nemůže být stejn$1,
+Date Of Retirement must be greater than Date of Joining,"Datum odchodu do důchodu, musí být větší než Datum spojování"
+Against Income Account,Proti účet příjmo,
+{0}% Delivered,{0}% vyhlášeno,
+Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Položka {0}: Objednané množství {1} nemůže být nižší než minimální Objednané množství {2} (definované v bodu).
+Monthly Distribution Percentage,Měsíční Distribution Procento,
+Territory Targets,Území Cíle,
+Transporter Info,Transporter Info,
+Purchase Order Item Supplied,Dodané položky vydané objednávky,
+Letter Heads for print templates.,Dopis hlavy na tiskových šablon.
+Titles for print templates e.g. Proforma Invoice.,"Tituly na tiskových šablon, např zálohové faktury."
+Valuation type charges can not marked as Inclusive,Poplatky typu ocenění může není označen jako Inclusive,
+Update Stock,Aktualizace skladem,
+Superfinishing,Superfinišováne,
+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.,"Různé UOM položky povede k nesprávné (celkem) Čistá hmotnost hodnoty. Ujistěte se, že čistá hmotnost každé položky je ve stejném nerozpuštěných."
+BOM Rate,BOM Rate,
+"<a href=""#Sales Browser/Territory"">Add / Edit</a>","<a href=""#Sales Browser/Territory""> Přidat / Upravit </a>"
+Please pull items from Delivery Note,"Prosím, vytáhněte položky z dodací list"
+Journal Entries {0} are un-linked,Zápisů {0} jsou un-spojeny,
+Terms,Podmínky,
+Create New,Vytvořit novy,
+Purchase Order Required,Vydaná objednávka je vyžadována,
+Item-wise Sales History,Item-moudrý Sales History,
+Total Sanctioned Amount,Celková částka potrestána,
+Purchase Analytics,Nákup Analytika,
+Delivery Note Item,Delivery Note Item,
+Task,Úkol,
+Shaving,Holeny,
+Reference Row #,Referenční Row #
+Batch number is mandatory for Item {0},Číslo šarže je povinné pro položku {0}
+This is a root sales person and cannot be edited.,To je kořen prodejní člověk a nelze upravovat.
+Stock Ledger,Reklamní Ledger,
+Salary Slip Deduction,Plat Slip Odpočet,
+"To set reorder level, item must be a Purchase Item","Chcete-li nastavit úroveň Objednací, položka musí být Nákup položky"
+Notes,Poznámky,
+From,Od,
+Select a group node first.,Vyberte první uzel skupinu.
+Purpose must be one of {0},Cíl musí být jedním z {0}
+Fill the form and save it,Vyplňte formulář a uložte jej,
+Download a report containing all raw materials with their latest inventory status,"Stáhněte si zprávu, která obsahuje všechny suroviny s jejich aktuální stav zásob"
+Facing,ObloženS,
+Leave Balance Before Application,Nechte zůstatek před aplikacS,
+Send SMS,Pošlete SMS,
+Default Letter Head,Výchozí hlavičkovS,
+Billable,ZúčtovatelnS,
+This will be used for setting rule in HR module,Tato adresa bude použita pro nastavení pravidlo HR modul,
+Rate at which this tax is applied,"Rychlost, při které se používá tato daň"
+Reorder Qty,Změna pořadí Množstvu,
+Stock Adjustment Account,Reklamní Nastavení účtu,
+Write Off,Odepsat,
+Operation ID,Provoz ID,
+"System User (login) ID. If set, it will become default for all HR forms.","System User (login) ID. Pokud je nastaveno, stane se výchozí pro všechny formy HR."
+{0}: From {1},{0}: Z {1}
+depends_on,záleží na,
+Opportunity Lost,Příležitost Ztracena,
+"Discount Fields will be available in Purchase Order, Purchase Receipt, Purchase Invoice","Sleva Pole bude k dispozici v objednávce, doklad o koupi, nákupní faktury"
+Report Type,Typ výpisu,
+Loading,Nahrávám,
+BOM Replace Tool,BOM Nahradit Tool,
+Country wise default Address Templates,Země moudrý výchozí adresa Templates,
+Due / Reference Date cannot be after {0},Vzhledem / Referenční datum nemůže být po {0}
+If you involve in manufacturing activity. Enables Item 'Is Manufactured',"Pokud se zapojit do výrobní činnosti. Umožňuje Položka ""se vyrábí"""
+Rounded Total,Zaoblený Total,
+List items that form the package.,"Seznam položek, které tvoří balíček."
+Percentage Allocation should be equal to 100%,Podíl alokace by měla být ve výši 100%
+Out of AMC,Out of AMC,
+Material Request Detail No,Materiál Poptávka Detail No,
+Hard turning,Hard soustruženC,
+Make Maintenance Visit,Proveďte návštěv údržby,
+Please contact to the user who have Sales Master Manager {0} role,"Prosím, kontaktujte pro uživatele, kteří mají obchodní manažer ve skupině Master {0} roli"
+Default Cash Account,Výchozí Peněžní účet,
+Company (not Customer or Supplier) master.,Company (nikoliv zákazník nebo dodavatel) master.
+Please enter 'Expected Delivery Date',"Prosím, zadejte ""Očekávaná Datum dodání"""
+"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.","Seznam své daňové hlavy (např DPH, spotřební daň, měli by mít jedinečné názvy) a jejich standardní sazby. Tím se vytvoří standardní šablonu, kterou si můžete upravit a přidat další později."
+Delivery Notes {0} must be cancelled before cancelling this Sales Order,Dodací listy {0} musí být zrušena před zrušením této prodejní objednávky,
+Paid amount + Write Off Amount can not be greater than Grand Total,Placená částka + odepsat Částka nesmí být větší než Grand Total,
+{0} is not a valid Batch Number for Item {1},{0} není platná Šarže pro Položku {1}
+Note: There is not enough leave balance for Leave Type {0},Poznámka: Není k dispozici dostatek zůstatek dovolené dovolená za kalendářní typ {0}
+"Note: If payment is not made against any reference, make Journal Entry manually.","Poznámka: Není-li platba provedena proti jakémukoli rozhodnutí, jak položka deníku ručně."
+Supplier Items,Dodavatele položky,
+Please enter atleast one attribute row in Item Variants table,Zadejte prosím aspoň jeden atribut řádek položky Varianty tabulku,
+Opportunity Type,Typ Příležitosti,
+New Company,Nová společnost,
+Cost Center is required for 'Profit and Loss' account {0},"Nákladové středisko je vyžadováno pro účet ""výkaz zisku a ztrát"" {0}"
+Transactions can only be deleted by the creator of the Company,Transakce mohou být vymazány pouze tvůrce Společnosti,
+Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Nesprávný počet hlavní knihy záznamů nalezen. Pravděpodobně jste zvolili nesprávný účet v transakci.
+To create a Bank Account,Chcete-li vytvořit si účet v bance,
+Publish Availability,Publikování Dostupnost,
+Date of Birth cannot be greater than today.,Datum narození nemůže být větší než dnes.
+Stock Ageing,Reklamní Stárnuty,
+Automatically updated from BOM table,Automaticky aktualizována z BOM tabulky,
+{0} '{1}' is disabled, {0} '{1}' je zakázána,
+Set as Open,Nastavit jako Otevřít,
+Send automatic emails to Contacts on Submitting transactions.,Posílat automatické e-maily na Kontakty na předložení transakcí.
+"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.
 					Available Qty: {4}, Transfer Qty: {5}","Row {0}: Množství nejsou dostupné iv skladu {1} na {2} {3}.
  Dispozici Množství: {4}, transfer Množství: {5}"
-DocType: Backup Manager,Sync with Dropbox,Synchronizace s Dropbox
-DocType: Event,Sunday,Neděle
-DocType: Sales Team,Contribution (%),Příspěvek (%)
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +412,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Poznámka: Položka Platba nebude vytvořili, protože ""v hotovosti nebo bankovním účtu"" nebyl zadán"
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +166,Responsibilities,Odpovědnost
-apps/erpnext/erpnext/stock/doctype/item/item_list.js +9,Template,Šablona
-DocType: Sales Person,Sales Person Name,Prodej Osoba Name
-apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,Zadejte prosím aspoň 1 fakturu v tabulce
-DocType: Pricing Rule,Item Group,Položka Group
-DocType: Task,Actual Start Date (via Time Logs),Skutečné datum Start (přes Time Záznamy)
-DocType: Stock Reconciliation Item,Before reconciliation,Před smíření
-apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.py +12,To {0},Chcete-li {0}
-DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Daně a poplatky Přidal (Company měna)
-apps/erpnext/erpnext/stock/doctype/item/item.py +334,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,"Položka Tax Row {0} musí mít účet typu daní či výnosů nebo nákladů, nebo Vyměřovací"
-DocType: Sales Order,Partly Billed,Částečně Účtovaný
-DocType: Item,Default BOM,Výchozí BOM
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +78,Decambering,Decambering
-apps/erpnext/erpnext/setup/doctype/company/company.js +17,Please re-type company name to confirm,Prosím re-typ název společnosti na potvrzení
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +70,Total Outstanding Amt,Celkem Vynikající Amt
-DocType: Time Log Batch,Total Hours,Celkem hodin
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +266,Total Debit must be equal to Total Credit. The difference is {0},Celkové inkaso musí rovnat do celkového kreditu. Rozdíl je {0}
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +10,Automotive,Automobilový
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +40,Leaves for type {0} already allocated for Employee {1} for Fiscal Year {0},Listy typu {0} již přidělené pro zaměstnance {1} pro fiskální rok {0}
-apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +15,Item is required,Položka je povinná
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +24,Metal injection molding,Kovové vstřikování
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +697,From Delivery Note,Z Dodacího Listu
-DocType: Time Log,From Time,Času od
-DocType: Notification Control,Custom Message,Custom Message
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +32,Investment Banking,Investiční bankovnictví
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +259,"Select your Country, Time Zone and Currency","Vyberte svou zemi, časové pásmo a měnu"
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +319,Cash or Bank Account is mandatory for making payment entry,V hotovosti nebo bankovním účtu je povinný pro výrobu zadání platebního
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +214,{0} {1} status is Unstopped,{0} {1} status je OdZastaveno
-DocType: Purchase Invoice,Price List Exchange Rate,Katalogová cena Exchange Rate
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +90,Pickling,Moření
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +17,Sand casting,Lití do písku
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +116,Electroplating,Electroplating
-DocType: Purchase Invoice Item,Rate,Rychlost
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +57,Intern,Internovat
-DocType: Newsletter,A Lead with this email id should exist,Lead s touto e-mailovou id by měla již existovat
-DocType: Stock Entry,From BOM,Od BOM
-DocType: Time Log,Billing Rate (per hour),Účtování Rate (za hodinu)
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +34,Basic,Základní
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +86,Stock transactions before {0} are frozen,Fotky transakce před {0} jsou zmrazeny
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +226,Please click on 'Generate Schedule',"Prosím, klikněte na ""Generovat Schedule"""
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +78,To Date should be same as From Date for Half Day leave,Chcete-li data by měla být stejná jako u Datum od půl dne volno
-apps/erpnext/erpnext/config/stock.py +110,"e.g. Kg, Unit, Nos, m","např Kg, ks, č, m"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +115,Reference No is mandatory if you entered Reference Date,"Referenční číslo je povinné, pokud jste zadali k rozhodnému dni"
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +104,Date of Joining must be greater than Date of Birth,Datum přistoupení musí být větší než Datum narození
-DocType: Salary Structure,Salary Structure,Plat struktura
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +237,"Multiple Price Rule exists with same criteria, please resolve \
+Sync with Dropbox,Synchronizace s Dropbox,
+Sunday,Neděle,
+Contribution (%),Příspěvek (%)
+Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Poznámka: Položka Platba nebude vytvořili, protože ""v hotovosti nebo bankovním účtu"" nebyl zadán"
+Responsibilities,Odpovědnost,
+Template,Šablona,
+Sales Person Name,Prodej Osoba Name,
+Please enter atleast 1 invoice in the table,Zadejte prosím aspoň 1 fakturu v tabulce,
+Item Group,Položka Group,
+Actual Start Date (via Time Logs),Skutečné datum Start (přes Time Záznamy)
+Before reconciliation,Před smířen$1,
+To {0},Chcete-li {0}
+Taxes and Charges Added (Company Currency),Daně a poplatky Přidal (Company měna)
+Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,"Položka Tax Row {0} musí mít účet typu daní či výnosů nebo nákladů, nebo Vyměřovací"
+Partly Billed,Částečně ÚčtovanM,
+Default BOM,Výchozí BOM,
+Decambering,Decambering,
+Please re-type company name to confirm,Prosím re-typ název společnosti na potvrzenM,
+Total Outstanding Amt,Celkem Vynikající Amt,
+Total Hours,Celkem hodin,
+Total Debit must be equal to Total Credit. The difference is {0},Celkové inkaso musí rovnat do celkového kreditu. Rozdíl je {0}
+Automotive,Automobilov$1,
+Leaves for type {0} already allocated for Employee {1} for Fiscal Year {0},Listy typu {0} již přidělené pro zaměstnance {1} pro fiskální rok {0}
+Item is required,Položka je povinnu,
+Metal injection molding,Kovové vstřikovánu,
+From Delivery Note,Z Dodacího Listu,
+From Time,Času od,
+Custom Message,Custom Message,
+Investment Banking,Investiční bankovnictvu,
+"Select your Country, Time Zone and Currency","Vyberte svou zemi, časové pásmo a měnu"
+Cash or Bank Account is mandatory for making payment entry,V hotovosti nebo bankovním účtu je povinný pro výrobu zadání platebního,
+{0} {1} status is Unstopped,{0} {1} status je OdZastaveno,
+Price List Exchange Rate,Katalogová cena Exchange Rate,
+Pickling,Mořeno,
+Sand casting,Lití do písku,
+Electroplating,Electroplating,
+Rate,Rychlost,
+Intern,Internovat,
+A Lead with this email id should exist,Lead s touto e-mailovou id by měla již existovat,
+From BOM,Od BOM,
+Billing Rate (per hour),Účtování Rate (za hodinu)
+Basic,Základny,
+Stock transactions before {0} are frozen,Fotky transakce před {0} jsou zmrazeny,
+Please click on 'Generate Schedule',"Prosím, klikněte na ""Generovat Schedule"""
+To Date should be same as From Date for Half Day leave,Chcete-li data by měla být stejná jako u Datum od půl dne volno,
+"e.g. Kg, Unit, Nos, m","např Kg, ks, č, m"
+Reference No is mandatory if you entered Reference Date,"Referenční číslo je povinné, pokud jste zadali k rozhodnému dni"
+Date of Joining must be greater than Date of Birth,Datum přistoupení musí být větší než Datum narozena,
+Salary Structure,Plat struktura,
+"Multiple Price Rule exists with same criteria, please resolve \
 			conflict by assigning priority. Price Rules: {0}","Multiple Cena existuje pravidlo se stejnými kritérii, prosím vyřešit \
  konflikt přiřazením prioritu. Cena Pravidla: {0}"
-DocType: Account,Bank,Banka
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +8,Airline,Letecká linka
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +511,Issue Material,Vydání Material
-DocType: Material Request Item,For Warehouse,Pro Sklad
-DocType: Employee,Offer Date,Nabídka Date
-DocType: Hub Settings,Access Token,Přístupový Token
-DocType: Sales Invoice Item,Serial No,Výrobní číslo
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +154,Please enter Maintaince Details first,"Prosím, zadejte první maintaince Podrobnosti"
-DocType: Item,Is Fixed Asset Item,Je dlouhodobého majetku Item
-DocType: Stock Entry,Including items for sub assemblies,Včetně položek pro podsestav
-DocType: Features Setup,"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","Máte-li dlouhé formáty tisku, tato funkce může být použita k rozdělení stránku se bude tisknout na více stránek se všemi záhlaví a zápatí na každé straně"
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +130,Hobbing,Odvalovací
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +93,All Territories,Všechny území
-DocType: Party Type,Party Type Name,Typ Party Name
-DocType: Purchase Invoice,Items,Položky
-DocType: Fiscal Year,Year Name,Jméno roku
-DocType: Salary Manager,Process Payroll,Proces Payroll
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +59,There are more holidays than working days this month.,Existují další svátky než pracovních dnů tento měsíc.
-DocType: Sales Partner,Sales Partner Name,Sales Partner Name
-DocType: Purchase Order Item,Image View,Image View
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +112,Finishing & industrial finishing,Povrchová úprava a průmyslového zpracování
-DocType: Issue,Opening Time,Otevírací doba
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +92,From and To dates required,Data OD a DO jsou vyžadována
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +45,Securities & Commodity Exchanges,Cenné papíry a komoditních burzách
-DocType: Shipping Rule,Calculate Based On,Vypočítat založené na
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +97,Drilling,Vrtání
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +27,Blow molding,Vyfukování
-DocType: Purchase Taxes and Charges,Valuation and Total,Oceňování a Total
-apps/erpnext/erpnext/stock/doctype/item/item.js +65,This Item is a Variant of {0} (Template). Attributes will be copied over from the template unless 'No Copy' is set,"Tento bod je varianta {0} (šablony). Atributy budou zkopírovány z šablony, pokud je nastaveno ""No Copy"""
-DocType: Account,Purchase User,Nákup Uživatel
-DocType: Sales Order,Customer's Purchase Order Number,Zákazníka Objednávka číslo
-DocType: Notification Control,Customize the Notification,Přizpůsobit oznámení
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +86,Hammering,Vyklepání
-DocType: Web Page,Slideshow,Promítání obrázků
-apps/erpnext/erpnext/utilities/doctype/address_template/address_template.py +24,Default Address Template cannot be deleted,Výchozí šablony adresy nemůže být smazán
-DocType: Sales Invoice,Shipping Rule,Přepravní Pravidlo
-DocType: Journal Entry,Print Heading,Tisk záhlaví
-DocType: Quotation,Maintenance Manager,Správce údržby
-DocType: Workflow State,Search,Hledat
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +54,Total cannot be zero,Celkem nemůže být nula
-apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +14,'Days Since Last Order' must be greater than or equal to zero,"""Dny od posledního Objednávky"" musí být větší nebo rovny nule"
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +141,Brazing,Pájení
-DocType: C-Form,Amended From,Platném znění
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +571,Raw Material,Surovina
-DocType: Leave Application,Follow via Email,Sledovat e-mailem
-DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Částka daně po slevě Částka
-apps/erpnext/erpnext/accounts/doctype/account/account.py +146,Child account exists for this account. You can not delete this account.,Dětské konto existuje pro tento účet. Nemůžete smazat tento účet.
-apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,Buď cílové množství nebo cílová částka je povinná
-apps/erpnext/erpnext/stock/get_item_details.py +421,No default BOM exists for Item {0},No default BOM existuje pro bod {0}
-DocType: Leave Allocation,Carry Forward,Převádět
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28,Cost Center with existing transactions can not be converted to ledger,Nákladové středisko se stávajícími transakcemi nelze převést na hlavní účetní knihy
-DocType: Department,Days for which Holidays are blocked for this department.,"Dnů, po které Prázdniny jsou blokovány pro toto oddělení."
-,Produced,Produkoval
-DocType: Issue,Raised By (Email),Vznesené (e-mail)
-DocType: Email Digest,General,Obecný
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +475,Attach Letterhead,Připojit Hlavičkový
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +272,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Nelze odečíst, pokud kategorie je určena pro ""ocenění"" nebo ""oceňování a celkový"""
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +244,Serial Nos Required for Serialized Item {0},Serial Nos Požadováno pro serializovaném bodu {0}
-DocType: Journal Entry,Bank Entry,Bank Entry
-DocType: Authorization Rule,Applicable To (Designation),Vztahující se na (označení)
-DocType: Blog Post,Blog Post,Příspěvek blogu
-apps/erpnext/erpnext/templates/generators/item.html +32,Add to Cart,Přidat do košíku
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Seskupit podle
-apps/erpnext/erpnext/config/accounts.py +133,Enable / disable currencies.,Povolit / zakázat měny.
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +114,Postal Expenses,Poštovní náklady
-apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Total (Amt)
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +25,Entertainment & Leisure,Entertainment & Leisure
-DocType: Purchase Order,The date on which recurring order will be stop,"Datum, ke kterému se opakující objednávka bude zastaví"
-DocType: Quality Inspection,Item Serial No,Položka Výrobní číslo
-apps/erpnext/erpnext/controllers/status_updater.py +102,{0} must be reduced by {1} or you should increase overflow tolerance,{0} musí být sníženy o {1} nebo byste měli zvýšit toleranci přesahu
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +56,Total Present,Celkem Present
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +575,Hour,Hodina
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +133,"Serialized Item {0} cannot be updated \
+Bank,Banka,
+Airline,Letecká linka,
+Issue Material,Vydání Material,
+For Warehouse,Pro Sklad,
+Offer Date,Nabídka Date,
+Access Token,Přístupový Token,
+Serial No,Výrobní číslo,
+Please enter Maintaince Details first,"Prosím, zadejte první maintaince Podrobnosti"
+Is Fixed Asset Item,Je dlouhodobého majetku Item,
+Including items for sub assemblies,Včetně položek pro podsestav,
+"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","Máte-li dlouhé formáty tisku, tato funkce může být použita k rozdělení stránku se bude tisknout na více stránek se všemi záhlaví a zápatí na každé straně"
+Hobbing,Odvalovace,
+All Territories,Všechny územe,
+Party Type Name,Typ Party Name,
+Items,Položky,
+Year Name,Jméno roku,
+Process Payroll,Proces Payroll,
+There are more holidays than working days this month.,Existují další svátky než pracovních dnů tento měsíc.
+Sales Partner Name,Sales Partner Name,
+Image View,Image View,
+Finishing & industrial finishing,Povrchová úprava a průmyslového zpracováne,
+Opening Time,Otevírací doba,
+From and To dates required,Data OD a DO jsou vyžadována,
+Securities & Commodity Exchanges,Cenné papíry a komoditních burzách,
+Calculate Based On,Vypočítat založené na,
+Drilling,Vrtáne,
+Blow molding,Vyfukováne,
+Valuation and Total,Oceňování a Total,
+This Item is a Variant of {0} (Template). Attributes will be copied over from the template unless 'No Copy' is set,"Tento bod je varianta {0} (šablony). Atributy budou zkopírovány z šablony, pokud je nastaveno ""No Copy"""
+Purchase User,Nákup Uživatel,
+Customer's Purchase Order Number,Zákazníka Objednávka číslo,
+Customize the Notification,Přizpůsobit oznámenl,
+Hammering,Vyklepánl,
+Slideshow,Promítání obrázkl,
+Default Address Template cannot be deleted,Výchozí šablony adresy nemůže být smazán,
+Shipping Rule,Přepravní Pravidlo,
+Print Heading,Tisk záhlavl,
+Maintenance Manager,Správce údržby,
+Search,Hledat,
+Total cannot be zero,Celkem nemůže být nula,
+'Days Since Last Order' must be greater than or equal to zero,"""Dny od posledního Objednávky"" musí být větší nebo rovny nule"
+Brazing,Pájena,
+Amended From,Platném zněna,
+Raw Material,Surovina,
+Follow via Email,Sledovat e-mailem,
+Tax Amount After Discount Amount,Částka daně po slevě Částka,
+Child account exists for this account. You can not delete this account.,Dětské konto existuje pro tento účet. Nemůžete smazat tento účet.
+Either target qty or target amount is mandatory,Buď cílové množství nebo cílová částka je povinn$1,
+No default BOM exists for Item {0},No default BOM existuje pro bod {0}
+Carry Forward,Převádět,
+Cost Center with existing transactions can not be converted to ledger,Nákladové středisko se stávajícími transakcemi nelze převést na hlavní účetní knihy,
+Days for which Holidays are blocked for this department.,"Dnů, po které Prázdniny jsou blokovány pro toto oddělení."
+Produced,Produkoval,
+Raised By (Email),Vznesené (e-mail)
+General,Obecn$1,
+Attach Letterhead,Připojit Hlavičkov$1,
+Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Nelze odečíst, pokud kategorie je určena pro ""ocenění"" nebo ""oceňování a celkový"""
+Serial Nos Required for Serialized Item {0},Serial Nos Požadováno pro serializovaném bodu {0}
+Bank Entry,Bank Entry,
+Applicable To (Designation),Vztahující se na (označení)
+Blog Post,Příspěvek blogu,
+Add to Cart,Přidat do košíku,
+Group By,Seskupit podle,
+Enable / disable currencies.,Povolit / zakázat měny.
+Postal Expenses,Poštovní náklady,
+Total(Amt),Total (Amt)
+Entertainment & Leisure,Entertainment & Leisure,
+The date on which recurring order will be stop,"Datum, ke kterému se opakující objednávka bude zastaví"
+Item Serial No,Položka Výrobní číslo,
+{0} must be reduced by {1} or you should increase overflow tolerance,{0} musí být sníženy o {1} nebo byste měli zvýšit toleranci přesahu,
+Total Present,Celkem Present,
+Hour,Hodina,
+"Serialized Item {0} cannot be updated \
 					using Stock Reconciliation","Serialized Položka {0} nelze aktualizovat \
  pomocí Reklamní Odsouhlasení"
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +480,Transfer Material to Supplier,Přeneste materiál Dodavateli
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +30,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,"New Pořadové číslo nemůže mít Warehouse. Warehouse musí být nastaveny Stock vstupním nebo doklad o koupi,"
-DocType: Lead,Lead Type,Lead Type
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +77,Create Quotation,Vytvořit Citace
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +316,All these items have already been invoiced,Všechny tyto položky již byly fakturovány
-apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Může být schválena {0}
-DocType: Shipping Rule,Shipping Rule Conditions,Přepravní Článek Podmínky
-DocType: BOM Replace Tool,The new BOM after replacement,Nový BOM po výměně
-DocType: Features Setup,Point of Sale,Místo Prodeje
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +82,Curling,Metaná
-DocType: Account,Tax,Daň
-apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +34,Row {0}: {1} is not a valid {2},Řádek {0}: {1} není platný {2}
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +88,Refining,Rafinace
-DocType: Production Planning Tool,Production Planning Tool,Plánování výroby Tool
-DocType: Quality Inspection,Report Date,Datum Reportu
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +129,Routing,Směrování
-DocType: C-Form,Invoices,Faktury
-DocType: Job Opening,Job Title,Název pozice
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +84,{0} Recipients,{0} příjemci
-DocType: Features Setup,Item Groups in Details,Položka skupiny v detailech
-apps/erpnext/erpnext/accounts/doctype/pos_setting/pos_setting.py +32,Expense Account is mandatory,Účtet nákladů je povinný
-apps/erpnext/erpnext/accounts/page/pos/pos.js +4,Start Point-of-Sale (POS),Start Point-of-Sale (POS)
-DocType: Item,A new variant (Item) will be created for each attribute value combination,Nová varianta (položka) se vytvoří pro každou kombinaci hodnoty atributu
-apps/erpnext/erpnext/config/support.py +28,Visit report for maintenance call.,Navštivte zprávu pro volání údržby.
-DocType: Stock Settings,Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.,"Procento máte možnost přijímat nebo dodávat více proti objednaného množství. Například: Pokud jste si objednali 100 kusů. a váš příspěvek je 10%, pak máte možnost získat 110 jednotek."
-DocType: Pricing Rule,Customer Group,Zákazník Group
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163,Expense account is mandatory for item {0},Účtet nákladů je povinný pro položku {0}
-DocType: Item,Website Description,Popis webu
-DocType: Serial No,AMC Expiry Date,AMC Datum vypršení platnosti
-,Sales Register,Sales Register
-DocType: Quotation,Quotation Lost Reason,Důvod ztráty nabídky
-DocType: Address,Plant,Rostlina
-apps/frappe/frappe/desk/moduleview.py +64,Setup,Nastavení
-apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Není nic upravovat.
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +38,Cold rolling,Válcování za studena
-DocType: Customer Group,Customer Group Name,Zákazník Group Name
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +358,Please remove this Invoice {0} from C-Form {1},Odeberte Tato faktura {0} z C-Form {1}
-DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,"Prosím, vyberte převádět pokud chcete také zahrnout uplynulý fiskální rok bilance listy tohoto fiskálního roku"
-DocType: GL Entry,Against Voucher Type,Proti poukazu typu
-DocType: POS Setting,POS Setting,POS Nastavení
-DocType: Packing Slip,Get Items,Získat položky
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +185,Please enter Write Off Account,"Prosím, zadejte odepsat účet"
-DocType: DocField,Image,Obrázek
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +220,Make Excise Invoice,Proveďte Spotřební faktury
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +628,Make Packing Slip,Proveďte dodacím listem
-DocType: Communication,Other,Ostatní
-DocType: C-Form,C-Form,C-Form
-apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +134,Operation ID not set,Provoz ID není nastaveno
-DocType: Production Order,Planned Start Date,Plánované datum zahájení
-DocType: Serial No,Creation Document Type,Tvorba Typ dokumentu
-DocType: Leave Type,Is Encash,Je inkasovat
-DocType: Purchase Invoice,Mobile No,Mobile No
-DocType: Payment Tool,Make Journal Entry,Proveďte položka deníku
-DocType: Leave Allocation,New Leaves Allocated,Nové Listy Přidělené
-apps/erpnext/erpnext/controllers/trends.py +257,Project-wise data is not available for Quotation,Data dle projektu nejsou k dispozici pro nabídku
-DocType: Project,Expected End Date,Očekávané datum ukončení
-DocType: Appraisal Template,Appraisal Template Title,Posouzení Template Název
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +366,Commercial,Obchodní
-DocType: Cost Center,Distribution Id,Distribuce Id
-apps/erpnext/erpnext/setup/page/setup_wizard/data/sample_home_page.html +14,Awesome Services,Skvělé služby
-apps/erpnext/erpnext/config/manufacturing.py +29,All Products or Services.,Všechny výrobky nebo služby.
-DocType: Purchase Invoice,Supplier Address,Dodavatel Address
-DocType: Contact Us Settings,Address Line 2,Adresní řádek 2
-DocType: ToDo,Reference,reference
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +58,Perforating,Perforující
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +35,Out Qty,Out Množství
-apps/erpnext/erpnext/config/accounts.py +118,Rules to calculate shipping amount for a sale,Pravidla pro výpočet výše přepravní na prodej
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +31,Series is mandatory,Série je povinné
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +27,Financial Services,Finanční služby
-DocType: Opportunity,Sales,Prodej
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +166,Warehouse required for stock Item {0},Sklad je vyžadován pro skladovou položku {0}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +87,Cr,Cr
-DocType: Customer,Default Receivable Accounts,Výchozí pohledávka účty
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +101,Sawing,Řezání
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +31,Laminating,Laminování
-DocType: Item Reorder,Transfer,Převod
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +567,Fetch exploded BOM (including sub-assemblies),Fetch explodovala kusovníku (včetně montážních podskupin)
-DocType: Authorization Rule,Applicable To (Employee),Vztahující se na (Employee)
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +142,Sintering,Spékání
-DocType: Journal Entry,Pay To / Recd From,Platit K / Recd Z
-DocType: Naming Series,Setup Series,Řada Setup
-DocType: Supplier,Contact HTML,Kontakt HTML
-DocType: Landed Cost Voucher,Purchase Receipts,Příjmky
-DocType: Payment Reconciliation,Maximum Amount,Maximální částka
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +27,How Pricing Rule is applied?,Jak Ceny pravidlo platí?
-DocType: Quality Inspection,Delivery Note No,Dodacího listu
-DocType: Company,Retail,Maloobchodní
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +106,Customer {0} does not exist,Zákazník {0} neexistuje
-DocType: Attendance,Absent,Nepřítomný
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +164,Crushing,Zdrcující
-DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Kupte Daně a poplatky šablony
-DocType: Upload Attendance,Download Template,Stáhnout šablonu
-DocType: GL Entry,Remarks,Poznámky
-DocType: Purchase Order Item Supplied,Raw Material Item Code,Surovina Kód položky
-DocType: Journal Entry,Write Off Based On,Odepsat založené na
-DocType: Features Setup,POS View,Zobrazení POS
-apps/erpnext/erpnext/config/stock.py +33,Installation record for a Serial No.,Instalace rekord pro sériové číslo
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +8,Continuous casting,Kontinuální lití
-sites/assets/js/erpnext.min.js +6,Please specify a,Uveďte prosím
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +490,Make Purchase Invoice,Proveďte nákupní faktury
-DocType: Offer Letter,Awaiting Response,Čeká odpověď
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +79,Cold sizing,Cold velikosti
-DocType: Salary Slip,Earning & Deduction,Výdělek a dedukce
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +70,Account {0} cannot be a Group,Účet {0} nemůže být skupina
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +257,Region,Kraj
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +208,Optional. This setting will be used to filter in various transactions.,Volitelné. Toto nastavení bude použito k filtrování v různých transakcí.
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +99,Negative Valuation Rate is not allowed,Negativní ocenění Rate není povoleno
-DocType: Holiday List,Weekly Off,Týdenní Off
-DocType: Fiscal Year,"For e.g. 2012, 2012-13","Pro např 2012, 2012-13"
-apps/erpnext/erpnext/setup/doctype/backup_manager/backup_manager.js +13,Dropbox,Dropbox
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +32,Provisional Profit / Loss (Credit),Prozatímní Zisk / ztráta (Credit)
-apps/erpnext/erpnext/accounts/utils.py +243,Please set default value {0} in Company {1},Prosím nastavte výchozí hodnotu {0} ve společnosti {1}
-DocType: Serial No,Creation Time,Čas vytvoření
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62,Total Revenue,Celkový příjem
-,Monthly Attendance Sheet,Měsíční Účast Sheet
-apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +17,No record found,Nebyl nalezen žádný záznam
-apps/erpnext/erpnext/controllers/stock_controller.py +174,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Nákladové středisko je povinná k položce {2}
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +73,Account {0} is inactive,Účet {0} je neaktivní
-DocType: GL Entry,Is Advance,Je Zálohová
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +20,Attendance From Date and Attendance To Date is mandatory,Účast Datum od a docházky do dnešního dne je povinná
-apps/erpnext/erpnext/controllers/buying_controller.py +132,Please enter 'Is Subcontracted' as Yes or No,"Prosím, zadejte ""subdodavatelům"" jako Ano nebo Ne"
-DocType: Sales Team,Contact No.,Kontakt Číslo
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61,'Profit and Loss' type account {0} not allowed in Opening Entry,"""Výkaz zisku a ztráty"" typ účtu {0} není povoleno pro Vstupní Údaj"
-DocType: Workflow State,Time,Čas
-DocType: Features Setup,Sales Discounts,Prodejní Slevy
-DocType: Hub Settings,Seller Country,Prodejce Country
-DocType: Authorization Rule,Authorization Rule,Autorizační pravidlo
-DocType: Sales Invoice,Terms and Conditions Details,Podmínky podrobnosti
-apps/erpnext/erpnext/templates/generators/item.html +49,Specifications,Specifikace
-DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Prodej Daně a poplatky šablony
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +9,Apparel & Accessories,Oblečení a doplňky
-DocType: Item,"Mandatory if Stock Item is ""Yes"". Also the default warehouse where reserved quantity is set from Sales Order.","Povinný, pokud skladem, je ""Ano"". Také výchozí sklad, kde je vyhrazeno množství nastavena od odběratele."
-apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +57,Number of Order,Číslo objednávky
-DocType: Item Group,HTML / Banner that will show on the top of product list.,"HTML / Banner, které se zobrazí na první místo v seznamu výrobků."
-DocType: Shipping Rule,Specify conditions to calculate shipping amount,Stanovení podmínek pro vypočítat výši poštovného
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +117,Add Child,Přidat dítě
-DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Role povoleno nastavit zmrazené účty a upravit Mražené Příspěvky
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +26,Cannot convert Cost Center to ledger as it has child nodes,"Nelze převést nákladového střediska na knihy, protože má podřízené uzly"
-apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +25,Conversion Factor is required,Je nutná konverzní faktor
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +32,Serial #,Serial #
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +87,Commission on Sales,Provize z prodeje
-DocType: Offer Letter Term,Value / Description,Hodnota / Popis
-,Customers Not Buying Since Long Time,Zákazníci nekupujete Po dlouhou dobu
-DocType: Production Order,Expected Delivery Date,Očekávané datum dodání
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +47,Bulging,Vyboulený
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +10,Evaporative-pattern casting,Lití Evaporative-pattern
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93,Entertainment Expenses,Výdaje na reprezentaci
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +176,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Prodejní faktury {0} musí být zrušena před zrušením této prodejní objednávky
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +34,Age,Věk
-DocType: Time Log,Billing Amount,Fakturace Částka
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Neplatný množství uvedené na položku {0}. Množství by mělo být větší než 0.
-apps/erpnext/erpnext/config/hr.py +18,Applications for leave.,Žádosti o dovolenou.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +144,Account with existing transaction can not be deleted,Účet s transakcemi nemůže být smazán
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,Legal Expenses,Výdaje na právní služby
-DocType: Sales Order,"The day of the month on which auto order will be generated e.g. 05, 28 etc","Den měsíce, ve kterém auto objednávka bude generován například 05, 28 atd"
-DocType: Sales Invoice,Posting Time,Čas zadání
-DocType: Sales Order,% Amount Billed,% Fakturované částky
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +129,Telephone Expenses,Telefonní Náklady
-DocType: Sales Partner,Logo,Logo
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +212,{0} Serial Numbers required for Item {0}. Only {0} provided.,{0} sériová čísla potřebné k položce {0}. Pouze {0} vyplněno.
-DocType: Naming Series,Check this if you want to force the user to select a series before saving. There will be no default if you check this.,"Zaškrtněte, pokud chcete, aby uživateli vybrat sérii před uložením. Tam bude žádná výchozí nastavení, pokud jste zkontrolovat."
-apps/erpnext/erpnext/stock/get_item_details.py +108,No Item with Serial No {0},No Položka s Serial č {0}
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Direct Expenses,Přímé náklady
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +645,Do you really want to UNSTOP this Material Request?,Opravdu chcete uvolnit tento materiál požadavek?
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Nový zákazník Příjmy
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Travel Expenses,Cestovní výdaje
-DocType: Maintenance Visit,Breakdown,Rozbor
-DocType: Bank Reconciliation Detail,Cheque Date,Šek Datum
-apps/erpnext/erpnext/accounts/doctype/account/account.py +43,Account {0}: Parent account {1} does not belong to company: {2},Účet {0}: Nadřazený účet {1} nepatří ke společnosti: {2}
-apps/erpnext/erpnext/setup/doctype/company/company.js +33,Successfully deleted all transactions related to this company!,Úspěšně vypouští všechny transakce související s tímto společnosti!
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +110,Honing,Honování
-DocType: Serial No,"Only Serial Nos with status ""Available"" can be delivered.","Serial pouze Nos se statusem ""K dispozici"" může být dodán."
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +53,Probation,Zkouška
-apps/erpnext/erpnext/stock/doctype/item/item.py +94,Default Warehouse is mandatory for stock Item.,Výchozí Sklad je povinný pro živočišnou položky.
-DocType: Feed,Full Name,Celé jméno/název
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +147,Clinching,Clinching
-apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.py +188,Payment of salary for the month {0} and year {1},Platba platu za měsíc {0} a rok {1}
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Paid Amount,Celkem uhrazené částky
-apps/erpnext/erpnext/accounts/general_ledger.py +91,Debit and Credit not equal for this voucher. Difference is {0}.,Debetní a kreditní nerovná této voucheru. Rozdíl je {0}.
-,Transferred Qty,Přenesená Množství
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +132,Planning,Plánování
-apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +9,Make Time Log Batch,Udělejte si čas Log Batch
-DocType: Project,Total Billing Amount (via Time Logs),Celkem Billing Částka (přes Time Záznamy)
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +577,We sell this Item,Nabízíme k prodeji tuto položku
-apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +66,Supplier Id,Dodavatel Id
-DocType: Journal Entry,Cash Entry,Cash Entry
-DocType: Sales Partner,Contact Desc,Kontakt Popis
-apps/erpnext/erpnext/stock/doctype/item/item.py +190,Item Variants {0} created,Bod Varianty {0} vytvořil
-apps/erpnext/erpnext/config/hr.py +135,"Type of leaves like casual, sick etc.","Typ ponechává jako neformální, nevolnosti atd."
-DocType: Email Digest,Send regular summary reports via Email.,Zasílat pravidelné souhrnné zprávy e-mailem.
-DocType: Cost Center,Add rows to set annual budgets on Accounts.,Přidat řádky stanovit roční rozpočty na účtech.
-DocType: Buying Settings,Default Supplier Type,Výchozí typ Dodavatel
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +159,Quarrying,Těžba
-DocType: Production Order,Total Operating Cost,Celkové provozní náklady
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +153,Note: Item {0} entered multiple times,Poznámka: Položka {0} vstoupil vícekrát
-apps/erpnext/erpnext/config/crm.py +27,All Contacts.,Všechny kontakty.
-DocType: Newsletter,Test Email Id,Testovací Email Id
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +392,Company Abbreviation,Zkratka Company
-DocType: Features Setup,If you follow Quality Inspection. Enables Item QA Required and QA No in Purchase Receipt,"Pokud se budete řídit kontroly jakosti. Umožňuje položky QA požadovány, a QA No v dokladu o koupi"
-DocType: GL Entry,Party Type,Typ Party
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +68,Raw material cannot be same as main Item,Surovina nemůže být stejný jako hlavní bod
-DocType: Item Attribute Value,Abbreviation,Zkratka
-apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Není authroized od {0} překročí limity
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +29,Rotational molding,Rotační tváření
-apps/erpnext/erpnext/config/hr.py +115,Salary template master.,Plat master šablona.
-DocType: Leave Type,Max Days Leave Allowed,Max Days Leave povolena
-DocType: Payment Tool,Set Matching Amounts,Nastavit Odpovídající Částky
-DocType: Purchase Invoice,Taxes and Charges Added,Daně a poplatky přidané
-,Sales Funnel,Prodej Nálevka
-apps/erpnext/erpnext/shopping_cart/utils.py +34,Cart,Vozík
-,Qty to Transfer,Množství pro přenos
-apps/erpnext/erpnext/config/selling.py +18,Quotes to Leads or Customers.,Nabídka pro Lead nebo pro Zákazníka
-DocType: Stock Settings,Role Allowed to edit frozen stock,Role povoleno upravovat zmrazené zásoby
-,Territory Target Variance Item Group-Wise,Území Cílová Odchylka Item Group-Wise
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +96,All Customer Groups,Všechny skupiny zákazníků
-apps/erpnext/erpnext/controllers/accounts_controller.py +366,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je povinné. Možná není vytvořen Měnový Směnný záznam pro {1} až {2}.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +37,Account {0}: Parent account {1} does not exist,Účet {0}: Nadřazený účet {1} neexistuje
-DocType: Purchase Invoice Item,Price List Rate (Company Currency),Ceník Rate (Company měny)
-apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +83,{0} {1} status is 'Stopped',"{0} {1} status je ""Zastaveno"""
-DocType: Account,Temporary,Dočasný
-DocType: Address,Preferred Billing Address,Preferovaná Fakturační Adresa
-DocType: Monthly Distribution Percentage,Percentage Allocation,Procento přidělení
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +81,Secretary,Sekretářka
-DocType: Serial No,Distinct unit of an Item,Samostatnou jednotku z položky
-apps/erpnext/erpnext/config/setup.py +96,Item master.,Master Item.
-DocType: Pricing Rule,Buying,Nákupy
-DocType: HR Settings,Employee Records to be created by,"Zaměstnanec Záznamy, které vytvořil"
-apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +24,This Time Log Batch has been cancelled.,To Batch Time Log byla zrušena.
-DocType: Purchase Invoice,Apply Discount On,Použít Sleva na
-DocType: Salary Slip Earning,Salary Slip Earning,Plat Slip Zisk
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +161,Creditors,Věřitelé
-DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Položka Wise Tax Detail
-,Item-wise Price List Rate,Item-moudrý Ceník Rate
-DocType: Purchase Order Item,Supplier Quotation,Dodavatel Nabídka
-DocType: Quotation,In Words will be visible once you save the Quotation.,"Ve slovech budou viditelné, jakmile uložíte nabídku."
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +67,Ironing,Žehlení
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +236,{0} {1} is stopped,{0} {1} je zastaven
-apps/erpnext/erpnext/stock/doctype/item/item.py +346,Barcode {0} already used in Item {1},Čárový kód {0} již použit u položky {1}
-DocType: Lead,Add to calendar on this date,Přidat do kalendáře k tomuto datu
-apps/erpnext/erpnext/config/selling.py +127,Rules for adding shipping costs.,Pravidla pro přidávání náklady na dopravu.
-apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Je nutná zákazník
-DocType: Letter Head,Letter Head,Záhlaví
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +32,Shrink fitting,Zmenšit kování
-DocType: Email Digest,Income / Expense,Výnosy / náklady
-DocType: Employee,Personal Email,Osobní e-mail
-apps/erpnext/erpnext/selling/report/territory_target_variance_item_group_wise/territory_target_variance_item_group_wise.py +58,Total Variance,Celkový rozptyl
-DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Pokud je povoleno, bude systém odesílat účetní položky k zásobám automaticky."
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +14,Brokerage,Makléřská
-DocType: Production Order Operation,"in Minutes
+Transfer Material to Supplier,Přeneste materiál Dodavateli,
+New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,"New Pořadové číslo nemůže mít Warehouse. Warehouse musí být nastaveny Stock vstupním nebo doklad o koupi,"
+Lead Type,Lead Type,
+Create Quotation,Vytvořit Citace,
+All these items have already been invoiced,Všechny tyto položky již byly fakturovány,
+Can be approved by {0},Může být schválena {0}
+Shipping Rule Conditions,Přepravní Článek Podmínky,
+The new BOM after replacement,Nový BOM po výměny,
+Point of Sale,Místo Prodeje,
+Curling,Metany,
+Tax,Day,
+Row {0}: {1} is not a valid {2},Řádek {0}: {1} není platný {2}
+Refining,Rafinace,
+Production Planning Tool,Plánování výroby Tool,
+Report Date,Datum Reportu,
+Routing,Směrováne,
+Invoices,Faktury,
+Job Title,Název pozice,
+{0} Recipients,{0} příjemci,
+Item Groups in Details,Položka skupiny v detailech,
+Expense Account is mandatory,Účtet nákladů je povinne,
+Start Point-of-Sale (POS),Start Point-of-Sale (POS)
+A new variant (Item) will be created for each attribute value combination,Nová varianta (položka) se vytvoří pro každou kombinaci hodnoty atributu,
+Visit report for maintenance call.,Navštivte zprávu pro volání údržby.
+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.,"Procento máte možnost přijímat nebo dodávat více proti objednaného množství. Například: Pokud jste si objednali 100 kusů. a váš příspěvek je 10%, pak máte možnost získat 110 jednotek."
+Customer Group,Zákazník Group,
+Expense account is mandatory for item {0},Účtet nákladů je povinný pro položku {0}
+Website Description,Popis webu,
+AMC Expiry Date,AMC Datum vypršení platnosti,
+Sales Register,Sales Register,
+Quotation Lost Reason,Důvod ztráty nabídky,
+Plant,Rostlina,
+Setup,Nastavenu,
+There is nothing to edit.,Není nic upravovat.
+Cold rolling,Válcování za studena,
+Customer Group Name,Zákazník Group Name,
+Please remove this Invoice {0} from C-Form {1},Odeberte Tato faktura {0} z C-Form {1}
+Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,"Prosím, vyberte převádět pokud chcete také zahrnout uplynulý fiskální rok bilance listy tohoto fiskálního roku"
+Against Voucher Type,Proti poukazu typu,
+POS Setting,POS Nastavenu,
+Get Items,Získat položky,
+Please enter Write Off Account,"Prosím, zadejte odepsat účet"
+Image,Obrázek,
+Make Excise Invoice,Proveďte Spotřební faktury,
+Make Packing Slip,Proveďte dodacím listem,
+Other,Ostatnk,
+C-Form,C-Form,
+Operation ID not set,Provoz ID není nastaveno,
+Planned Start Date,Plánované datum zahájenk,
+Creation Document Type,Tvorba Typ dokumentu,
+Is Encash,Je inkasovat,
+Mobile No,Mobile No,
+Make Journal Entry,Proveďte položka deníku,
+New Leaves Allocated,Nové Listy Přidělenk,
+Project-wise data is not available for Quotation,Data dle projektu nejsou k dispozici pro nabídku,
+Expected End Date,Očekávané datum ukončenk,
+Appraisal Template Title,Posouzení Template Název,
+Commercial,Obchodnk,
+Distribution Id,Distribuce Id,
+Awesome Services,Skvělé služby,
+All Products or Services.,Všechny výrobky nebo služby.
+Supplier Address,Dodavatel Address,
+Address Line 2,Adresní řádek 2,
+Reference,reference,
+Perforating,Perforujícs,
+Out Qty,Out Množstvs,
+Rules to calculate shipping amount for a sale,Pravidla pro výpočet výše přepravní na prodej,
+Series is mandatory,Série je povinns,
+Financial Services,Finanční služby,
+Sales,Prodej,
+Warehouse required for stock Item {0},Sklad je vyžadován pro skladovou položku {0}
+Cr,Cr,
+Default Receivable Accounts,Výchozí pohledávka účty,
+Sawing,Řezánr,
+Laminating,Laminovánr,
+Transfer,Převod,
+Fetch exploded BOM (including sub-assemblies),Fetch explodovala kusovníku (včetně montážních podskupin)
+Applicable To (Employee),Vztahující se na (Employee)
+Sintering,SpékánZ,
+Pay To / Recd From,Platit K / Recd Z,
+Setup Series,Řada Setup,
+Contact HTML,Kontakt HTML,
+Purchase Receipts,Příjmky,
+Maximum Amount,Maximální částka,
+How Pricing Rule is applied?,Jak Ceny pravidlo platí?
+Delivery Note No,Dodacího listu,
+Retail,Maloobchodnu,
+Customer {0} does not exist,Zákazník {0} neexistuje,
+Absent,Nepřítomnu,
+Crushing,Zdrcujícu,
+Purchase Taxes and Charges Template,Kupte Daně a poplatky šablony,
+Download Template,Stáhnout šablonu,
+Remarks,Poznámky,
+Raw Material Item Code,Surovina Kód položky,
+Write Off Based On,Odepsat založené na,
+POS View,Zobrazení POS,
+Installation record for a Serial No.,Instalace rekord pro sériové číslo,
+Continuous casting,Kontinuální litu,
+Please specify a,Uveďte prosím,
+Make Purchase Invoice,Proveďte nákupní faktury,
+Awaiting Response,Čeká odpověu,
+Cold sizing,Cold velikosti,
+Earning & Deduction,Výdělek a dedukce,
+Account {0} cannot be a Group,Účet {0} nemůže být skupina,
+Region,Kraj,
+Optional. This setting will be used to filter in various transactions.,Volitelné. Toto nastavení bude použito k filtrování v různých transakcí.
+Negative Valuation Rate is not allowed,Negativní ocenění Rate není povoleno,
+Weekly Off,Týdenní Off,
+"For e.g. 2012, 2012-13","Pro např 2012, 2012-13"
+Dropbox,Dropbox,
+Provisional Profit / Loss (Credit),Prozatímní Zisk / ztráta (Credit)
+Please set default value {0} in Company {1},Prosím nastavte výchozí hodnotu {0} ve společnosti {1}
+Creation Time,Čas vytvořenm,
+Total Revenue,Celkový příjem,
+Monthly Attendance Sheet,Měsíční Účast Sheet,
+No record found,Nebyl nalezen žádný záznam,
+{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Nákladové středisko je povinná k položce {2}
+Account {0} is inactive,Účet {0} je neaktivn$1,
+Is Advance,Je Zálohov$1,
+Attendance From Date and Attendance To Date is mandatory,Účast Datum od a docházky do dnešního dne je povinn$1,
+Please enter 'Is Subcontracted' as Yes or No,"Prosím, zadejte ""subdodavatelům"" jako Ano nebo Ne"
+Contact No.,Kontakt Číslo,
+'Profit and Loss' type account {0} not allowed in Opening Entry,"""Výkaz zisku a ztráty"" typ účtu {0} není povoleno pro Vstupní Údaj"
+Time,Čas,
+Sales Discounts,Prodejní Slevy,
+Seller Country,Prodejce Country,
+Authorization Rule,Autorizační pravidlo,
+Terms and Conditions Details,Podmínky podrobnosti,
+Specifications,Specifikace,
+Sales Taxes and Charges Template,Prodej Daně a poplatky šablony,
+Apparel & Accessories,Oblečení a doplňky,
+"Mandatory if Stock Item is ""Yes"". Also the default warehouse where reserved quantity is set from Sales Order.","Povinný, pokud skladem, je ""Ano"". Také výchozí sklad, kde je vyhrazeno množství nastavena od odběratele."
+Number of Order,Číslo objednávky,
+HTML / Banner that will show on the top of product list.,"HTML / Banner, které se zobrazí na první místo v seznamu výrobků."
+Specify conditions to calculate shipping amount,Stanovení podmínek pro vypočítat výši poštovného,
+Add Child,Přidat díto,
+Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Role povoleno nastavit zmrazené účty a upravit Mražené Příspěvky,
+Cannot convert Cost Center to ledger as it has child nodes,"Nelze převést nákladového střediska na knihy, protože má podřízené uzly"
+Conversion Factor is required,Je nutná konverzní faktor,
+Serial #,Serial #
+Commission on Sales,Provize z prodeje,
+Value / Description,Hodnota / Popis,
+Customers Not Buying Since Long Time,Zákazníci nekupujete Po dlouhou dobu,
+Expected Delivery Date,Očekávané datum dodáne,
+Bulging,Vyboulene,
+Evaporative-pattern casting,Lití Evaporative-pattern,
+Entertainment Expenses,Výdaje na reprezentaci,
+Sales Invoice {0} must be cancelled before cancelling this Sales Order,Prodejní faktury {0} musí být zrušena před zrušením této prodejní objednávky,
+Age,Věk,
+Billing Amount,Fakturace Částka,
+Invalid quantity specified for item {0}. Quantity should be greater than 0.,Neplatný množství uvedené na položku {0}. Množství by mělo být větší než 0.
+Applications for leave.,Žádosti o dovolenou.
+Account with existing transaction can not be deleted,Účet s transakcemi nemůže být smazán,
+Legal Expenses,Výdaje na právní služby,
+"The day of the month on which auto order will be generated e.g. 05, 28 etc","Den měsíce, ve kterém auto objednávka bude generován například 05, 28 atd"
+Posting Time,Čas zadány,
+% Amount Billed,% Fakturované částky,
+Telephone Expenses,Telefonní Náklady,
+Logo,Logo,
+{0} Serial Numbers required for Item {0}. Only {0} provided.,{0} sériová čísla potřebné k položce {0}. Pouze {0} vyplněno.
+Check this if you want to force the user to select a series before saving. There will be no default if you check this.,"Zaškrtněte, pokud chcete, aby uživateli vybrat sérii před uložením. Tam bude žádná výchozí nastavení, pokud jste zkontrolovat."
+No Item with Serial No {0},No Položka s Serial č {0}
+Direct Expenses,Přímé náklady,
+Do you really want to UNSTOP this Material Request?,Opravdu chcete uvolnit tento materiál požadavek?
+New Customer Revenue,Nový zákazník Příjmy,
+Travel Expenses,Cestovní výdaje,
+Breakdown,Rozbor,
+Cheque Date,Šek Datum,
+Account {0}: Parent account {1} does not belong to company: {2},Účet {0}: Nadřazený účet {1} nepatří ke společnosti: {2}
+Successfully deleted all transactions related to this company!,Úspěšně vypouští všechny transakce související s tímto společnosti!
+Honing,Honován$1,
+"Only Serial Nos with status ""Available"" can be delivered.","Serial pouze Nos se statusem ""K dispozici"" může být dodán."
+Probation,Zkouška,
+Default Warehouse is mandatory for stock Item.,Výchozí Sklad je povinný pro živočišnou položky.
+Full Name,Celé jméno/název,
+Clinching,Clinching,
+Payment of salary for the month {0} and year {1},Platba platu za měsíc {0} a rok {1}
+Total Paid Amount,Celkem uhrazené částky,
+Debit and Credit not equal for this voucher. Difference is {0}.,Debetní a kreditní nerovná této voucheru. Rozdíl je {0}.
+Transferred Qty,Přenesená Množstvh,
+Planning,Plánovánh,
+Make Time Log Batch,Udělejte si čas Log Batch,
+Total Billing Amount (via Time Logs),Celkem Billing Částka (přes Time Záznamy)
+We sell this Item,Nabízíme k prodeji tuto položku,
+Supplier Id,Dodavatel Id,
+Cash Entry,Cash Entry,
+Contact Desc,Kontakt Popis,
+Item Variants {0} created,Bod Varianty {0} vytvořil,
+"Type of leaves like casual, sick etc.","Typ ponechává jako neformální, nevolnosti atd."
+Send regular summary reports via Email.,Zasílat pravidelné souhrnné zprávy e-mailem.
+Add rows to set annual budgets on Accounts.,Přidat řádky stanovit roční rozpočty na účtech.
+Default Supplier Type,Výchozí typ Dodavatel,
+Quarrying,Těžba,
+Total Operating Cost,Celkové provozní náklady,
+Note: Item {0} entered multiple times,Poznámka: Položka {0} vstoupil vícekrát,
+All Contacts.,Všechny kontakty.
+Test Email Id,Testovací Email Id,
+Company Abbreviation,Zkratka Company,
+If you follow Quality Inspection. Enables Item QA Required and QA No in Purchase Receipt,"Pokud se budete řídit kontroly jakosti. Umožňuje položky QA požadovány, a QA No v dokladu o koupi"
+Party Type,Typ Party,
+Raw material cannot be same as main Item,Surovina nemůže být stejný jako hlavní bod,
+Abbreviation,Zkratka,
+Not authroized since {0} exceeds limits,Není authroized od {0} překročí limity,
+Rotational molding,Rotační tvářeny,
+Salary template master.,Plat master šablona.
+Max Days Leave Allowed,Max Days Leave povolena,
+Set Matching Amounts,Nastavit Odpovídající Částky,
+Taxes and Charges Added,Daně a poplatky přidana,
+Sales Funnel,Prodej Nálevka,
+Cart,Vozík,
+Qty to Transfer,Množství pro přenos,
+Quotes to Leads or Customers.,Nabídka pro Lead nebo pro Zákazníka,
+Role Allowed to edit frozen stock,Role povoleno upravovat zmrazené zásoby,
+Territory Target Variance Item Group-Wise,Území Cílová Odchylka Item Group-Wise,
+All Customer Groups,Všechny skupiny zákazníka,
+{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je povinné. Možná není vytvořen Měnový Směnný záznam pro {1} až {2}.
+Account {0}: Parent account {1} does not exist,Účet {0}: Nadřazený účet {1} neexistuje,
+Price List Rate (Company Currency),Ceník Rate (Company měny)
+{0} {1} status is 'Stopped',"{0} {1} status je ""Zastaveno"""
+Temporary,Dočasna,
+Preferred Billing Address,Preferovaná Fakturační Adresa,
+Percentage Allocation,Procento přidělena,
+Secretary,Sekretářka,
+Distinct unit of an Item,Samostatnou jednotku z položky,
+Item master.,Master Item.
+Buying,Nákupy,
+Employee Records to be created by,"Zaměstnanec Záznamy, které vytvořil"
+This Time Log Batch has been cancelled.,To Batch Time Log byla zrušena.
+Apply Discount On,Použít Sleva na,
+Salary Slip Earning,Plat Slip Zisk,
+Creditors,Věřitela,
+Item Wise Tax Detail,Položka Wise Tax Detail,
+Item-wise Price List Rate,Item-moudrý Ceník Rate,
+Supplier Quotation,Dodavatel Nabídka,
+In Words will be visible once you save the Quotation.,"Ve slovech budou viditelné, jakmile uložíte nabídku."
+Ironing,Žehlenn,
+{0} {1} is stopped,{0} {1} je zastaven,
+Barcode {0} already used in Item {1},Čárový kód {0} již použit u položky {1}
+Add to calendar on this date,Přidat do kalendáře k tomuto datu,
+Rules for adding shipping costs.,Pravidla pro přidávání náklady na dopravu.
+Customer is required,Je nutná zákazník,
+Letter Head,Záhlavk,
+Shrink fitting,Zmenšit kovánk,
+Income / Expense,Výnosy / náklady,
+Personal Email,Osobní e-mail,
+Total Variance,Celkový rozptyl,
+"If enabled, the system will post accounting entries for inventory automatically.","Pokud je povoleno, bude systém odesílat účetní položky k zásobám automaticky."
+Brokerage,Makléřsks,
+"in Minutes,
 Updated via 'Time Log'","v minutách 
  aktualizovat přes ""Time Log"""
-DocType: Customer,From Lead,Od Leadu
-apps/erpnext/erpnext/config/manufacturing.py +19,Orders released for production.,Objednávky uvolněna pro výrobu.
-apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +42,Select Fiscal Year...,Vyberte fiskálního roku ...
-DocType: Hub Settings,Name Token,Jméno Token
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +105,Planing,Hoblování
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +159,Standard Selling,Standardní prodejní
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +153,Atleast one warehouse is mandatory,Alespoň jeden sklad je povinný
-DocType: Serial No,Out of Warranty,Out of záruky
-DocType: BOM Replace Tool,Replace,Vyměnit
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +281,{0} against Sales Invoice {1},{0} na Prodejní Faktuře {1}
-apps/erpnext/erpnext/stock/doctype/item/item.py +47,Please enter default Unit of Measure,"Prosím, zadejte výchozí měrnou jednotku"
-DocType: Purchase Invoice Item,Project Name,Název projektu
-DocType: Workflow State,Edit,Upravit
-DocType: Journal Entry Account,If Income or Expense,Pokud je výnos nebo náklad
-DocType: Email Digest,New Support Tickets,Nová podpora Vstupenky
-DocType: Features Setup,Item Batch Nos,Položka Batch Nos
-DocType: Stock Ledger Entry,Stock Value Difference,Reklamní Value Rozdíl
-DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Platba Odsouhlasení Platba
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +36,Tax Assets,Daňové Aktiva
-DocType: BOM Item,BOM No,BOM No
-DocType: Contact Us Settings,Pincode,PSČ
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +147,Journal Entry {0} does not have account {1} or already matched against other voucher,Zápis do deníku {0} nemá účet {1} nebo již uzavřeno proti ostatním poukaz
-DocType: Item,Moving Average,Klouzavý průměr
-DocType: BOM Replace Tool,The BOM which will be replaced,"BOM, který bude nahrazen"
-apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +21,New Stock UOM must be different from current stock UOM,New Sklad UOM musí být odlišný od běžného akciové nerozpuštěných
-DocType: Account,Debit,Debet
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +32,Leaves must be allocated in multiples of 0.5,"Listy musí být přiděleny v násobcích 0,5"
-DocType: Production Order,Operation Cost,Provozní náklady
-apps/erpnext/erpnext/config/hr.py +71,Upload attendance from a .csv file,Nahrajte účast ze souboru CSV
-apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Outstanding Amt,Vynikající Amt
-DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Nastavit cíle Item Group-moudrý pro tento prodeje osobě.
-DocType: Warranty Claim,"To assign this issue, use the ""Assign"" button in the sidebar.","Chcete-li přiřadit tento problém vyřešit, použijte tlačítko ""Přiřadit"" v postranním panelu."
-DocType: Stock Settings,Freeze Stocks Older Than [Days],Freeze Zásoby Starší než [dny]
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +40,"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.","Pokud dva nebo více pravidla pro tvorbu cen se nacházejí na základě výše uvedených podmínek, priorita je aplikována. Priorita je číslo od 0 do 20, zatímco výchozí hodnota je nula (prázdný). Vyšší číslo znamená, že bude mít přednost, pokud existuje více pravidla pro tvorbu cen se za stejných podmínek."
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +42,Against Invoice,Na základě faktury
-apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Fiskální rok: {0} neexistuje
-DocType: Currency Exchange,To Currency,Chcete-li měny
-DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Nechte následující uživatelé schválit Žádost o dovolenou.
-apps/erpnext/erpnext/config/hr.py +155,Types of Expense Claim.,Druhy výdajů nároku.
-DocType: Item,Taxes,Daně
-DocType: Project,Default Cost Center,Výchozí Center Náklady
-DocType: Purchase Invoice,End Date,Datum ukončení
-DocType: Employee,Internal Work History,Vnitřní práce History
-DocType: DocField,Column Break,Zalomení sloupce
-DocType: Event,Thursday,Čtvrtek
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +41,Private Equity,Private Equity
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +92,Turning,Turning
-DocType: Maintenance Visit,Customer Feedback,Zpětná vazba od zákazníků
-DocType: Account,Expense,Výdaj
-DocType: Sales Invoice,Exhibition,Výstava
-apps/erpnext/erpnext/stock/utils.py +89,Item {0} ignored since it is not a stock item,"Položka {0} ignorována, protože to není skladem"
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +28,Submit this Production Order for further processing.,Odeslat tento výrobní zakázka pro další zpracování.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +21,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Nechcete-li použít Ceník článek v dané transakce, by měly být všechny platné pravidla pro tvorbu cen zakázáno."
-DocType: Company,Domain,Doména
-,Sales Order Trends,Prodejní objednávky Trendy
-DocType: Employee,Held On,Které se konalo dne
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +24,Production Item,Výrobní položka
-,Employee Information,Informace o zaměstnanci
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +502,Rate (%),Rate (%)
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +405,Financial Year End Date,Finanční rok Datum ukončení
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +32,"Can not filter based on Voucher No, if grouped by Voucher","Nelze filtrovat na základě poukazu ne, pokud seskupeny podle poukazu"
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +502,Make Supplier Quotation,Vytvořit nabídku dodavatele
-DocType: Quality Inspection,Incoming,Přicházející
-DocType: Item,Name and Description,Jméno a popis
-apps/erpnext/erpnext/stock/doctype/item/item.py +134,"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.","Výchozí Měrná jednotka nelze změnit, přímo, protože jste již nějaké transakce (y) s jiným nerozpuštěných. Chcete-li změnit výchozí UOM, použijte ""UOM Nahradit Utility"" nástroj pod Stock modulu."
-DocType: BOM,Materials Required (Exploded),Potřebný materiál (Rozložený)
-DocType: Salary Structure Earning,Reduce Earning for Leave Without Pay (LWP),Snížit Zisk na vstup bez nároku na mzdu (LWP)
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +44,Casual Leave,Casual Leave
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +92,Credit To account must be a liability account,Připsat na účet musí být účet závazek
-DocType: Batch,Batch ID,Šarže ID
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +303,Note: {0},Poznámka: {0}
-,Delivery Note Trends,Dodací list Trendy
-apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +72,{0} must be a Purchased or Sub-Contracted Item in row {1},"{0} musí být Zakoupená, nebo Subdodavatelská položka v řádku {1}"
-apps/erpnext/erpnext/accounts/general_ledger.py +100,Account: {0} can only be updated via Stock Transactions,Účet: {0} lze aktualizovat pouze prostřednictvím Skladových Transakcí
-DocType: GL Entry,Party,Strana
-DocType: Sales Order,Delivery Date,Dodávka Datum
-DocType: DocField,Currency,Měna
-DocType: Opportunity,Opportunity Date,Příležitost Datum
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_list.js +10,To Bill,Billa
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +56,Piecework,Úkolová práce
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +64,Avg. Buying Rate,Avg. Nákup Rate
-DocType: Task,Actual Time (in Hours),Skutečná doba (v hodinách)
-DocType: Employee,History In Company,Historie ve Společnosti
-DocType: Address,Shipping,Lodní
-DocType: Stock Ledger Entry,Stock Ledger Entry,Reklamní Ledger Entry
-DocType: Department,Leave Block List,Nechte Block List
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +203,Item {0} is not setup for Serial Nos. Column must be blank,Položka {0} není nastavení pro Serial č. Sloupec musí být prázdný
-DocType: Accounts Settings,Accounts Settings,Nastavení účtu
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +53,Plant and Machinery,Továrna a strojní zařízení
-DocType: Item,You can enter the minimum quantity of this item to be ordered.,Můžete zadat minimální množství této položky do objednávky.
-DocType: Sales Partner,Partner's Website,Partnera Website
-DocType: Opportunity,To Discuss,K projednání
-DocType: SMS Settings,SMS Settings,Nastavení SMS
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +60,Temporary Accounts,Dočasné Účty
-DocType: Payment Tool,Column Break 1,Zalomení sloupce 1
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +150,Black,Černá
-DocType: BOM Explosion Item,BOM Explosion Item,BOM Explosion Item
-DocType: Account,Auditor,Auditor
-DocType: Purchase Order,End date of current order's period,Datum ukončení doby aktuální objednávky
-apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +17,Make Offer Letter,Vytvořte nabídku Letter
-DocType: DocField,Fold,Fold
-DocType: Production Order Operation,Production Order Operation,Výrobní zakázka Operace
-DocType: Pricing Rule,Disable,Zakázat
-DocType: Project Task,Pending Review,Čeká Review
-sites/assets/js/desk.min.js +558,Please specify,Prosím specifikujte
-DocType: Task,Total Expense Claim (via Expense Claim),Total Expense Claim (via Expense nároku)
-apps/erpnext/erpnext/accounts/report/sales_register/sales_register.py +65,Customer Id,Zákazník Id
-DocType: Page,Page Name,Název stránky
-DocType: Purchase Invoice,Exchange Rate,Exchange Rate
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +422,Sales Order {0} is not submitted,Prodejní objednávky {0} není předložena
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0}: Parent account {1} does not bolong to the company {2},Sklad {0}: Nadřazený účet {1} napatří společnosti {2}
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +123,Spindle finishing,Úprava vřetena
-DocType: Material Request,% of materials ordered against this Material Request,% Materiálů objednáno proti tomuto požadavku Materiál
-DocType: BOM,Last Purchase Rate,Last Cena při platbě
-DocType: Account,Asset,Majetek
-DocType: Project Task,Task ID,Task ID
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +393,"e.g. ""MC""","např ""MC """
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +75,Stock cannot exist for Item {0} since has variants,"Sklad nemůže existovat k bodu {0}, protože má varianty"
-,Sales Person-wise Transaction Summary,Prodej Person-moudrý Shrnutí transakce
-DocType: System Settings,Time Zone,Časové pásmo
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +104,Warehouse {0} does not exist,Sklad {0} neexistuje
-apps/erpnext/erpnext/hub_node/page/hub/register_in_hub.html +2,Register For ERPNext Hub,Registrace pro ERPNext Hub
-DocType: Monthly Distribution,Monthly Distribution Percentages,Měsíční Distribuční Procenta
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +16,The selected item cannot have Batch,Vybraná položka nemůže mít dávku
-DocType: Delivery Note,% of materials delivered against this Delivery Note,% Materiálů doručeno proti tomuto dodacímu listu
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +150,Stapling,Sešívání
-DocType: Customer,Customer Details,Podrobnosti zákazníků
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +104,Shaping,Tvarování
-DocType: Employee,Reports to,Zprávy
-DocType: SMS Settings,Enter url parameter for receiver nos,Zadejte url parametr pro přijímače nos
-DocType: Sales Invoice,Paid Amount,Uhrazené částky
-apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +25,Closing Account {0} must be of type 'Liability',"Závěrečný účet {0} musí být typu ""odpovědnosti"""
-,Available Stock for Packing Items,K dispozici skladem pro balení položek
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +275,Reserved Warehouse is missing in Sales Order,Reserved Warehouse chybí odběratele
-DocType: Item Variant,Item Variant,Položka Variant
-apps/erpnext/erpnext/utilities/doctype/address_template/address_template.py +15,Setting this Address Template as default as there is no other default,"Nastavení Tato adresa šablonu jako výchozí, protože není jiná výchozí"
-apps/erpnext/erpnext/accounts/doctype/account/account.py +71,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Zůstatek na účtu již v inkasa, není dovoleno stanovit ""Balance musí být"" jako ""úvěru"""
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +71,Quality Management,Řízení kvality
-DocType: Production Planning Tool,Filter based on customer,Filtr dle zákazníka
-DocType: Payment Tool Detail,Against Voucher No,Proti poukaz č
-apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +46,Please enter quantity for Item {0},"Zadejte prosím množství produktů, bod {0}"
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +35,Warning: Sales Order {0} already exists against same Purchase Order number,Upozornění: prodejní objednávky {0} již existuje proti stejnému číslo objednávky
-DocType: Employee External Work History,Employee External Work History,Zaměstnanec vnější práce History
-DocType: Notification Control,Purchase,Nákup
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +178,Status of {0} {1} is now {2},Stav {0} {1} je nyní {2}
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +29,Balance Qty,Zůstatek Množství
-DocType: Item Group,Parent Item Group,Parent Item Group
-apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +18,{0} for {1},{0} na {1}
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +92,Cost Centers,Nákladové středisko
-apps/erpnext/erpnext/config/stock.py +115,Warehouses.,Sklady.
-DocType: Purchase Order,Rate at which supplier's currency is converted to company's base currency,"Sazba, za kterou dodavatel měny je převeden na společnosti základní měny"
-apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Row # {0}: časování v rozporu s řadou {1}
-DocType: Employee,Employment Type,Typ zaměstnání
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +40,Fixed Assets,Dlouhodobý majetek
-DocType: Item Group,Default Expense Account,Výchozí výdajového účtu
-DocType: Employee,Notice (days),Oznámení (dny)
-DocType: Page,Yes,Ano
-DocType: Cost Center,Material User,Materiál Uživatel
-DocType: Employee,Encashment Date,Inkaso Datum
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +73,Electroforming,Electroforming
-apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +147,"Against Voucher Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Proti poukazu Type musí být jedním z objednávky, faktury nebo Journal Entry"
-DocType: Account,Stock Adjustment,Reklamní Nastavení
-DocType: Production Order,Planned Operating Cost,Plánované provozní náklady
-apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +118,New {0} Name,Nový {0} Název
-apps/erpnext/erpnext/controllers/recurring_document.py +126,Please find attached {0} #{1},V příloze naleznete {0} # {1}
-DocType: Global Defaults,jsonrates.com API Key,jsonrates.com API Key
-DocType: Job Applicant,Applicant Name,Žadatel Název
-DocType: Authorization Rule,Customer / Item Name,Zákazník / Název zboží
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Serial No is mandatory for Item {0},Pořadové číslo je povinná k bodu {0}
-sites/assets/js/desk.min.js +536,Created By,Vytvořeno (kým)
-DocType: Serial No,Under AMC,Podle AMC
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +47,Item valuation rate is recalculated considering landed cost voucher amount,Bod míra ocenění je přepočítána zvažuje přistál nákladů částku poukazu
-apps/erpnext/erpnext/config/selling.py +65,Default settings for selling transactions.,Výchozí nastavení pro prodejní transakce.
-DocType: BOM Replace Tool,Current BOM,Aktuální BOM
-sites/assets/js/erpnext.min.js +5,Add Serial No,Přidat Sériové číslo
-DocType: Production Order,Warehouses,Sklady
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Print and Stationary,Print a Stacionární
-apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +119,Group Node,Group Node
-DocType: Payment Reconciliation,Minimum Amount,Minimální částka
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +68,Update Finished Goods,Dokončení aktualizace zboží
-DocType: Item,"Automatically set. If this item has variants, then it cannot be selected in sales orders etc.","Automatické nastavení. Pokud je tato položka má varianty, pak to nemůže být zvolen do prodejních objednávek atd"
-DocType: Workstation,per hour,za hodinu
-apps/frappe/frappe/core/doctype/doctype/doctype.py +97,Series {0} already used in {1},Série {0} jsou již použity v {1}
-DocType: Warehouse,Account for the warehouse (Perpetual Inventory) will be created under this Account.,"Účet pro skladu (průběžné inventarizace), bude vytvořena v rámci tohoto účtu."
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +95,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Warehouse nelze vypustit, neboť existuje zásob, kniha pro tento sklad."
-DocType: Company,Distribution,Distribuce
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +86,Project Manager,Project Manager
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +67,Dispatch,Odeslání
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +70,Max discount allowed for item: {0} is {1}%,Max sleva povoleno položku: {0} {1}%
-DocType: Account,Receivable,Pohledávky
-DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,"Role, která se nechá podat transakcí, které přesahují úvěrové limity."
-DocType: Sales Invoice,Supplier Reference,Dodavatel Označení
-DocType: Production Planning Tool,"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.","Je-li zaškrtnuto, bude BOM pro sub-montážní položky považují pro získání surovin. V opačném případě budou všechny sub-montážní položky být zacházeno jako surovinu."
-DocType: Material Request,Material Issue,Material Issue
-DocType: Hub Settings,Seller Description,Prodejce Popis
-DocType: Item,Is Stock Item,Je skladem
-DocType: Shopping Cart Price List,Shopping Cart Price List,Nákupní košík Ceník
-DocType: Employee Education,Qualification,Kvalifikace
-DocType: Item Price,Item Price,Položka Cena
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +47,Soap & Detergent,Soap & Detergent
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +35,Motion Picture & Video,Motion Picture & Video
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Objednáno
-DocType: Company,Default Settings,Výchozí nastavení
-DocType: Warehouse,Warehouse Name,Název Skladu
-DocType: Naming Series,Select Transaction,Vybrat Transaction
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,Zadejte Schvalování role nebo Schvalování Uživatel
-DocType: Journal Entry,Write Off Entry,Odepsat Vstup
-DocType: BOM,Rate Of Materials Based On,Hodnotit materiálů na bázi
-apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Podpora Analtyics
-DocType: Journal Entry,eg. Cheque Number,např. číslo šeku
-apps/erpnext/erpnext/accounts/doctype/accounts_settings/accounts_settings.py +25,Company is missing in warehouses {0},Společnost chybí ve skladech {0}
-DocType: Stock UOM Replace Utility,Stock UOM Replace Utility,Sklad UOM Nahradit Utility
-DocType: POS Setting,Terms and Conditions,Podmínky
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,To Date should be within the Fiscal Year. Assuming To Date = {0},"Chcete-li data by měla být v rámci fiskálního roku. Za předpokladu, že To Date = {0}"
-DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Zde si můžete udržet výšku, váhu, alergie, zdravotní problémy atd"
-DocType: Leave Block List,Applies to Company,Platí pro firmy
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +156,Cannot cancel because submitted Stock Entry {0} exists,"Nelze zrušit, protože předložena Reklamní Entry {0} existuje"
-DocType: Purchase Invoice,In Words,Slovy
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +204,Today is {0}'s birthday!,Dnes je {0} 's narozeniny!
-DocType: Production Planning Tool,Material Request For Warehouse,Materiál Request For Warehouse
-DocType: Sales Order Item,For Production,Pro Výrobu
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +107,Please enter sales order in the above table,"Prosím, zadejte prodejní objednávky v tabulce výše"
-DocType: Project Task,View Task,Zobrazit Task
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +404,Your financial year begins on,Váš finanční rok začíná
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +46,Please enter Purchase Receipts,"Prosím, zadejte Nákup Příjmy"
-DocType: Sales Invoice,Get Advances Received,Získat přijaté zálohy
-DocType: Email Digest,Add/Remove Recipients,Přidat / Odebrat příjemce
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +471,Transaction not allowed against stopped Production Order {0},Transakce není povoleno proti zastavila výrobu Objednat {0}
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","Chcete-li nastavit tento fiskální rok jako výchozí, klikněte na tlačítko ""Nastavit jako výchozí"""
-apps/erpnext/erpnext/config/support.py +54,Setup incoming server for support email id. (e.g. support@example.com),Nastavení příchozí server pro podporu e-mailovou id. (Např support@example.com)
-apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +35,Shortage Qty,Nedostatek Množství
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +79,Row{0}: Party Type and Party is required for Receivable / Payable account {1},Row {0}: Type Party Party a je nutné pro pohledávky / závazky na účtu {1}
-DocType: Salary Slip,Salary Slip,Plat Slip
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +115,Burnishing,Leštění
-DocType: Features Setup,To enable <b>Point of Sale</b> view,Chcete-li povolit <b> Point of Sale </ b> Zobrazit
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +54,'To Date' is required,"""Datum DO"" je povinné"
-DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generování balení pásky pro obaly mají být dodány. Používá se k oznámit číslo balíku, obsah balení a jeho hmotnost."
-DocType: Sales Invoice Item,Sales Order Item,Prodejní objednávky Item
-DocType: Salary Slip,Payment Days,Platební dny
-DocType: BOM,Manage cost of operations,Správa nákladů na provoz
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +86,Make Credit Note,Proveďte dobropis
-DocType: Features Setup,Item Advanced,Položka Advanced
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +39,Hot rolling,Válcování
-DocType: Notification Control,"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.","Když některý z kontrolovaných operací je ""Odesláno"", email pop-up automaticky otevřeny poslat e-mail na přidružené ""Kontakt"" v této transakci, s transakcí jako přílohu. Uživatel může, ale nemusí odeslat e-mail."
-apps/erpnext/erpnext/config/setup.py +101,Customer master.,Master zákazníků.
-apps/erpnext/erpnext/config/setup.py +14,Global Settings,Globální nastavení
-DocType: Employee Education,Employee Education,Vzdělávání zaměstnanců
-DocType: Salary Slip,Net Pay,Net Pay
-DocType: Account,Account,Účet
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227,Serial No {0} has already been received,Pořadové číslo {0} již obdržel
-,Requested Items To Be Transferred,Požadované položky mají být převedeny
-DocType: Purchase Invoice,Recurring Id,Opakující se Id
-DocType: Customer,Sales Team Details,Podrobnosti prodejní tým
-DocType: Expense Claim,Total Claimed Amount,Celkem žalované částky
-apps/erpnext/erpnext/config/crm.py +22,Potential opportunities for selling.,Potenciální příležitosti pro prodej.
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +46,Sick Leave,Zdravotní dovolená
-DocType: Email Digest,Email Digest,Email Digest
-DocType: Delivery Note,Billing Address Name,Jméno Fakturační adresy
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +21,Department Stores,Obchodní domy
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +39,System Balance,System Balance
-DocType: Workflow,Is Active,Je Aktivní
-apps/erpnext/erpnext/controllers/stock_controller.py +70,No accounting entries for the following warehouses,Žádné účetní záznamy pro následující sklady
-apps/erpnext/erpnext/projects/doctype/project/project.js +22,Save the document first.,Uložte dokument jako první.
-DocType: Account,Chargeable,Vyměřovací
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +120,Linishing,Linishing
-DocType: Company,Change Abbreviation,Změna Zkratky
-DocType: Workflow State,Primary,Primární
-DocType: Expense Claim Detail,Expense Date,Datum výdaje
-DocType: Item,Max Discount (%),Max sleva (%)
-apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +60,Last Order Amount,Poslední částka objednávky
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +160,Blasting,Odstřel
-DocType: Company,Warn,Varovat
-apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +82,Item valuation updated,Ocenění Item aktualizováno
-DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Jakékoli jiné poznámky, pozoruhodné úsilí, které by měly jít v záznamech."
-DocType: BOM,Manufacturing User,Výroba Uživatel
-DocType: Purchase Order,Raw Materials Supplied,Dodává suroviny
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +239,Total valuation ({0}) for manufactured or repacked item(s) can not be less than total valuation of raw materials ({1}),Ocenění Total ({0}) pro vyrobené nebo zabalil položku (y) nesmí být menší než celková ocenění surovin ({1})
-DocType: Email Digest,New Projects,Nové projekty
-DocType: Communication,Series,Série
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +28,Expected Delivery Date cannot be before Purchase Order Date,"Očekávané datum dodání, nemůže být před zakoupením pořadí Datum"
-DocType: Appraisal,Appraisal Template,Posouzení Template
-DocType: Communication,Email,Email
-DocType: Item Group,Item Classification,Položka Klasifikace
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +84,Business Development Manager,Business Development Manager
-DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Maintenance Visit Účel
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +15,Period,Období
-,General Ledger,Hlavní Účetní Kniha
-apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Zobrazit Vodítka
-DocType: Item Attribute Value,Attribute Value,Hodnota atributu
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +65,"Email id must be unique, already exists for {0}","E-mail id musí být jedinečný, již existuje {0}"
-,Itemwise Recommended Reorder Level,Itemwise Doporučené Změna pořadí Level
-apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +216,Please select {0} first,"Prosím, nejprve vyberte {0} "
-DocType: Features Setup,To get Item Group in details table,Chcete-li získat položku Group v tabulce Rozpis
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +66,Redrawing,Překreslení
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +119,Etching,Lept
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +55,Commission,Provize
-apps/erpnext/erpnext/templates/pages/ticket.py +31,You are not allowed to reply to this ticket.,Nejste oprávnění odpovědět na tento lístek.
-DocType: Address Template,"<h4>Default Template</h4>
+From Lead,Od Leadu,
+Orders released for production.,Objednávky uvolněna pro výrobu.
+Select Fiscal Year...,Vyberte fiskálního roku ...
+Name Token,Jméno Token,
+Planing,Hoblovánn,
+Standard Selling,Standardní prodejnn,
+Atleast one warehouse is mandatory,Alespoň jeden sklad je povinnn,
+Out of Warranty,Out of záruky,
+Replace,Vyměnit,
+{0} against Sales Invoice {1},{0} na Prodejní Faktuře {1}
+Please enter default Unit of Measure,"Prosím, zadejte výchozí měrnou jednotku"
+Project Name,Název projektu,
+Edit,Upravit,
+If Income or Expense,Pokud je výnos nebo náklad,
+New Support Tickets,Nová podpora Vstupenky,
+Item Batch Nos,Položka Batch Nos,
+Stock Value Difference,Reklamní Value Rozdíl,
+Payment Reconciliation Payment,Platba Odsouhlasení Platba,
+Tax Assets,Daňové Aktiva,
+BOM No,BOM No,
+Pincode,PSu,
+Journal Entry {0} does not have account {1} or already matched against other voucher,Zápis do deníku {0} nemá účet {1} nebo již uzavřeno proti ostatním poukaz,
+Moving Average,Klouzavý průměr,
+The BOM which will be replaced,"BOM, který bude nahrazen"
+New Stock UOM must be different from current stock UOM,New Sklad UOM musí být odlišný od běžného akciové nerozpuštěných,
+Debit,Debet,
+Leaves must be allocated in multiples of 0.5,"Listy musí být přiděleny v násobcích 0,5"
+Operation Cost,Provozní náklady,
+Upload attendance from a .csv file,Nahrajte účast ze souboru CSV,
+Outstanding Amt,Vynikající Amt,
+Set targets Item Group-wise for this Sales Person.,Nastavit cíle Item Group-moudrý pro tento prodeje osobě.
+"To assign this issue, use the ""Assign"" button in the sidebar.","Chcete-li přiřadit tento problém vyřešit, použijte tlačítko ""Přiřadit"" v postranním panelu."
+Freeze Stocks Older Than [Days],Freeze Zásoby Starší než [dny]
+"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.","Pokud dva nebo více pravidla pro tvorbu cen se nacházejí na základě výše uvedených podmínek, priorita je aplikována. Priorita je číslo od 0 do 20, zatímco výchozí hodnota je nula (prázdný). Vyšší číslo znamená, že bude mít přednost, pokud existuje více pravidla pro tvorbu cen se za stejných podmínek."
+Against Invoice,Na základě faktury,
+Fiscal Year: {0} does not exists,Fiskální rok: {0} neexistuje,
+To Currency,Chcete-li měny,
+Allow the following users to approve Leave Applications for block days.,Nechte následující uživatelé schválit Žádost o dovolenou.
+Types of Expense Claim.,Druhy výdajů nároku.
+Taxes,Dany,
+Default Cost Center,Výchozí Center Náklady,
+End Date,Datum ukončeny,
+Internal Work History,Vnitřní práce History,
+Column Break,Zalomení sloupce,
+Thursday,Čtvrtek,
+Private Equity,Private Equity,
+Turning,Turning,
+Customer Feedback,Zpětná vazba od zákazníky,
+Expense,Výdaj,
+Exhibition,Výstava,
+Item {0} ignored since it is not a stock item,"Položka {0} ignorována, protože to není skladem"
+Submit this Production Order for further processing.,Odeslat tento výrobní zakázka pro další zpracování.
+"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Nechcete-li použít Ceník článek v dané transakce, by měly být všechny platné pravidla pro tvorbu cen zakázáno."
+Domain,Doména,
+Sales Order Trends,Prodejní objednávky Trendy,
+Held On,Které se konalo dne,
+Production Item,Výrobní položka,
+Employee Information,Informace o zaměstnanci,
+Rate (%),Rate (%)
+Financial Year End Date,Finanční rok Datum ukončen$1,
+"Can not filter based on Voucher No, if grouped by Voucher","Nelze filtrovat na základě poukazu ne, pokud seskupeny podle poukazu"
+Make Supplier Quotation,Vytvořit nabídku dodavatele,
+Incoming,Přicházejíce,
+Name and Description,Jméno a popis,
+"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.","Výchozí Měrná jednotka nelze změnit, přímo, protože jste již nějaké transakce (y) s jiným nerozpuštěných. Chcete-li změnit výchozí UOM, použijte ""UOM Nahradit Utility"" nástroj pod Stock modulu."
+Materials Required (Exploded),Potřebný materiál (Rozložený)
+Reduce Earning for Leave Without Pay (LWP),Snížit Zisk na vstup bez nároku na mzdu (LWP)
+Casual Leave,Casual Leave,
+Credit To account must be a liability account,Připsat na účet musí být účet závazek,
+Batch ID,Šarže ID,
+Note: {0},Poznámka: {0}
+Delivery Note Trends,Dodací list Trendy,
+{0} must be a Purchased or Sub-Contracted Item in row {1},"{0} musí být Zakoupená, nebo Subdodavatelská položka v řádku {1}"
+Account: {0} can only be updated via Stock Transactions,Účet: {0} lze aktualizovat pouze prostřednictvím Skladových Transakca,
+Party,Strana,
+Delivery Date,Dodávka Datum,
+Currency,Měna,
+Opportunity Date,Příležitost Datum,
+To Bill,Billa,
+Piecework,Úkolová práce,
+Avg. Buying Rate,Avg. Nákup Rate,
+Actual Time (in Hours),Skutečná doba (v hodinách)
+History In Company,Historie ve Společnosti,
+Shipping,Lodni,
+Stock Ledger Entry,Reklamní Ledger Entry,
+Leave Block List,Nechte Block List,
+Item {0} is not setup for Serial Nos. Column must be blank,Položka {0} není nastavení pro Serial č. Sloupec musí být prázdni,
+Accounts Settings,Nastavení účtu,
+Plant and Machinery,Továrna a strojní zařízeni,
+You can enter the minimum quantity of this item to be ordered.,Můžete zadat minimální množství této položky do objednávky.
+Partner's Website,Partnera Website,
+To Discuss,K projednáne,
+SMS Settings,Nastavení SMS,
+Temporary Accounts,Dočasné Účty,
+Column Break 1,Zalomení sloupce 1,
+Black,Černe,
+BOM Explosion Item,BOM Explosion Item,
+Auditor,Auditor,
+End date of current order's period,Datum ukončení doby aktuální objednávky,
+Make Offer Letter,Vytvořte nabídku Letter,
+Fold,Fold,
+Production Order Operation,Výrobní zakázka Operace,
+Disable,Zakázat,
+Pending Review,Čeká Review,
+Please specify,Prosím specifikujte,
+Total Expense Claim (via Expense Claim),Total Expense Claim (via Expense nároku)
+Customer Id,Zákazník Id,
+Page Name,Název stránky,
+Exchange Rate,Exchange Rate,
+Sales Order {0} is not submitted,Prodejní objednávky {0} není předložena,
+Warehouse {0}: Parent account {1} does not bolong to the company {2},Sklad {0}: Nadřazený účet {1} napatří společnosti {2}
+Spindle finishing,Úprava vřetena,
+% of materials ordered against this Material Request,% Materiálů objednáno proti tomuto požadavku Materiál,
+Last Purchase Rate,Last Cena při platba,
+Asset,Majetek,
+Task ID,Task ID,
+"e.g. ""MC""","např ""MC """
+Stock cannot exist for Item {0} since has variants,"Sklad nemůže existovat k bodu {0}, protože má varianty"
+Sales Person-wise Transaction Summary,Prodej Person-moudrý Shrnutí transakce,
+Time Zone,Časové pásmo,
+Warehouse {0} does not exist,Sklad {0} neexistuje,
+Register For ERPNext Hub,Registrace pro ERPNext Hub,
+Monthly Distribution Percentages,Měsíční Distribuční Procenta,
+The selected item cannot have Batch,Vybraná položka nemůže mít dávku,
+% of materials delivered against this Delivery Note,% Materiálů doručeno proti tomuto dodacímu listu,
+Stapling,Sešíváne,
+Customer Details,Podrobnosti zákazníke,
+Shaping,Tvarováne,
+Reports to,Zprávy,
+Enter url parameter for receiver nos,Zadejte url parametr pro přijímače nos,
+Paid Amount,Uhrazené částky,
+Closing Account {0} must be of type 'Liability',"Závěrečný účet {0} musí být typu ""odpovědnosti"""
+Available Stock for Packing Items,K dispozici skladem pro balení položek,
+Reserved Warehouse is missing in Sales Order,Reserved Warehouse chybí odběratele,
+Item Variant,Položka Variant,
+Setting this Address Template as default as there is no other default,"Nastavení Tato adresa šablonu jako výchozí, protože není jiná výchozí"
+"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Zůstatek na účtu již v inkasa, není dovoleno stanovit ""Balance musí být"" jako ""úvěru"""
+Quality Management,Řízení kvality,
+Filter based on customer,Filtr dle zákazníka,
+Against Voucher No,Proti poukaz y,
+Please enter quantity for Item {0},"Zadejte prosím množství produktů, bod {0}"
+Warning: Sales Order {0} already exists against same Purchase Order number,Upozornění: prodejní objednávky {0} již existuje proti stejnému číslo objednávky,
+Employee External Work History,Zaměstnanec vnější práce History,
+Purchase,Nákup,
+Status of {0} {1} is now {2},Stav {0} {1} je nyní {2}
+Balance Qty,Zůstatek Množstvp,
+Parent Item Group,Parent Item Group,
+{0} for {1},{0} na {1}
+Cost Centers,Nákladové středisko,
+Warehouses.,Sklady.
+Rate at which supplier's currency is converted to company's base currency,"Sazba, za kterou dodavatel měny je převeden na společnosti základní měny"
+Row #{0}: Timings conflicts with row {1},Row # {0}: časování v rozporu s řadou {1}
+Employment Type,Typ zaměstnánk,
+Fixed Assets,Dlouhodobý majetek,
+Default Expense Account,Výchozí výdajového účtu,
+Notice (days),Oznámení (dny)
+Yes,Ano,
+Material User,Materiál Uživatel,
+Encashment Date,Inkaso Datum,
+Electroforming,Electroforming,
+"Against Voucher Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Proti poukazu Type musí být jedním z objednávky, faktury nebo Journal Entry"
+Stock Adjustment,Reklamní Nastaveny,
+Planned Operating Cost,Plánované provozní náklady,
+New {0} Name,Nový {0} Název,
+Please find attached {0} #{1},V příloze naleznete {0} # {1}
+jsonrates.com API Key,jsonrates.com API Key,
+Applicant Name,Žadatel Název,
+Customer / Item Name,Zákazník / Název zbožy,
+Serial No is mandatory for Item {0},Pořadové číslo je povinná k bodu {0}
+Created By,Vytvořeno (kým)
+Under AMC,Podle AMC,
+Item valuation rate is recalculated considering landed cost voucher amount,Bod míra ocenění je přepočítána zvažuje přistál nákladů částku poukazu,
+Default settings for selling transactions.,Výchozí nastavení pro prodejní transakce.
+Current BOM,Aktuální BOM,
+Add Serial No,Přidat Sériové číslo,
+Warehouses,Sklady,
+Print and Stationary,Print a StacionárnM,
+Group Node,Group Node,
+Minimum Amount,Minimální částka,
+Update Finished Goods,Dokončení aktualizace zbožM,
+"Automatically set. If this item has variants, then it cannot be selected in sales orders etc.","Automatické nastavení. Pokud je tato položka má varianty, pak to nemůže být zvolen do prodejních objednávek atd"
+per hour,za hodinu,
+Series {0} already used in {1},Série {0} jsou již použity v {1}
+Account for the warehouse (Perpetual Inventory) will be created under this Account.,"Účet pro skladu (průběžné inventarizace), bude vytvořena v rámci tohoto účtu."
+Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Warehouse nelze vypustit, neboť existuje zásob, kniha pro tento sklad."
+Distribution,Distribuce,
+Project Manager,Project Manager,
+Dispatch,Odesláne,
+Max discount allowed for item: {0} is {1}%,Max sleva povoleno položku: {0} {1}%
+Receivable,Pohledávky,
+Role that is allowed to submit transactions that exceed credit limits set.,"Role, která se nechá podat transakcí, které přesahují úvěrové limity."
+Supplier Reference,Dodavatel Označen$1,
+"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.","Je-li zaškrtnuto, bude BOM pro sub-montážní položky považují pro získání surovin. V opačném případě budou všechny sub-montážní položky být zacházeno jako surovinu."
+Material Issue,Material Issue,
+Seller Description,Prodejce Popis,
+Is Stock Item,Je skladem,
+Shopping Cart Price List,Nákupní košík Ceník,
+Qualification,Kvalifikace,
+Item Price,Položka Cena,
+Soap & Detergent,Soap & Detergent,
+Motion Picture & Video,Motion Picture & Video,
+Ordered,Objednáno,
+Default Settings,Výchozí nastavene,
+Warehouse Name,Název Skladu,
+Select Transaction,Vybrat Transaction,
+Please enter Approving Role or Approving User,Zadejte Schvalování role nebo Schvalování Uživatel,
+Write Off Entry,Odepsat Vstup,
+Rate Of Materials Based On,Hodnotit materiálů na bázi,
+Support Analtyics,Podpora Analtyics,
+eg. Cheque Number,např. číslo šeku,
+Company is missing in warehouses {0},Společnost chybí ve skladech {0}
+Stock UOM Replace Utility,Sklad UOM Nahradit Utility,
+Terms and Conditions,Podmínky,
+To Date should be within the Fiscal Year. Assuming To Date = {0},"Chcete-li data by měla být v rámci fiskálního roku. Za předpokladu, že To Date = {0}"
+"Here you can maintain height, weight, allergies, medical concerns etc","Zde si můžete udržet výšku, váhu, alergie, zdravotní problémy atd"
+Applies to Company,Platí pro firmy,
+Cannot cancel because submitted Stock Entry {0} exists,"Nelze zrušit, protože předložena Reklamní Entry {0} existuje"
+In Words,Slovy,
+Today is {0}'s birthday!,Dnes je {0} 's narozeniny!
+Material Request For Warehouse,Materiál Request For Warehouse,
+For Production,Pro Výrobu,
+Please enter sales order in the above table,"Prosím, zadejte prodejní objednávky v tabulce výše"
+View Task,Zobrazit Task,
+Your financial year begins on,Váš finanční rok začínk,
+Please enter Purchase Receipts,"Prosím, zadejte Nákup Příjmy"
+Get Advances Received,Získat přijaté zálohy,
+Add/Remove Recipients,Přidat / Odebrat příjemce,
+Transaction not allowed against stopped Production Order {0},Transakce není povoleno proti zastavila výrobu Objednat {0}
+"To set this Fiscal Year as Default, click on 'Set as Default'","Chcete-li nastavit tento fiskální rok jako výchozí, klikněte na tlačítko ""Nastavit jako výchozí"""
+Setup incoming server for support email id. (e.g. support@example.com),Nastavení příchozí server pro podporu e-mailovou id. (Např support@example.com)
+Shortage Qty,Nedostatek Množstv$1,
+Row{0}: Party Type and Party is required for Receivable / Payable account {1},Row {0}: Type Party Party a je nutné pro pohledávky / závazky na účtu {1}
+Salary Slip,Plat Slip,
+Burnishing,Leštěnp,
+To enable <b>Point of Sale</b> view,Chcete-li povolit <b> Point of Sale </ b> Zobrazit,
+'To Date' is required,"""Datum DO"" je povinné"
+"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generování balení pásky pro obaly mají být dodány. Používá se k oznámit číslo balíku, obsah balení a jeho hmotnost."
+Sales Order Item,Prodejní objednávky Item,
+Payment Days,Platební dny,
+Manage cost of operations,Správa nákladů na provoz,
+Make Credit Note,Proveďte dobropis,
+Item Advanced,Položka Advanced,
+Hot rolling,Válcovánm,
+"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.","Když některý z kontrolovaných operací je ""Odesláno"", email pop-up automaticky otevřeny poslat e-mail na přidružené ""Kontakt"" v této transakci, s transakcí jako přílohu. Uživatel může, ale nemusí odeslat e-mail."
+Customer master.,Master zákazníků.
+Global Settings,Globální nastaveny,
+Employee Education,Vzdělávání zaměstnancy,
+Net Pay,Net Pay,
+Account,Účet,
+Serial No {0} has already been received,Pořadové číslo {0} již obdržel,
+Requested Items To Be Transferred,Požadované položky mají být převedeny,
+Recurring Id,Opakující se Id,
+Sales Team Details,Podrobnosti prodejní tým,
+Total Claimed Amount,Celkem žalované částky,
+Potential opportunities for selling.,Potenciální příležitosti pro prodej.
+Sick Leave,Zdravotní dovolent,
+Email Digest,Email Digest,
+Billing Address Name,Jméno Fakturační adresy,
+Department Stores,Obchodní domy,
+System Balance,System Balance,
+Is Active,Je Aktivnt,
+No accounting entries for the following warehouses,Žádné účetní záznamy pro následující sklady,
+Save the document first.,Uložte dokument jako první.
+Chargeable,Vyměřovacg,
+Linishing,Linishing,
+Change Abbreviation,Změna Zkratky,
+Primary,Primárng,
+Expense Date,Datum výdaje,
+Max Discount (%),Max sleva (%)
+Last Order Amount,Poslední částka objednávky,
+Blasting,Odstřel,
+Warn,Varovat,
+Item valuation updated,Ocenění Item aktualizováno,
+"Any other remarks, noteworthy effort that should go in the records.","Jakékoli jiné poznámky, pozoruhodné úsilí, které by měly jít v záznamech."
+Manufacturing User,Výroba Uživatel,
+Raw Materials Supplied,Dodává suroviny,
+Total valuation ({0}) for manufactured or repacked item(s) can not be less than total valuation of raw materials ({1}),Ocenění Total ({0}) pro vyrobené nebo zabalil položku (y) nesmí být menší než celková ocenění surovin ({1})
+New Projects,Nové projekty,
+Series,Série,
+Expected Delivery Date cannot be before Purchase Order Date,"Očekávané datum dodání, nemůže být před zakoupením pořadí Datum"
+Appraisal Template,Posouzení Template,
+Email,Email,
+Item Classification,Položka Klasifikace,
+Business Development Manager,Business Development Manager,
+Maintenance Visit Purpose,Maintenance Visit Účel,
+Period,Obdobe,
+General Ledger,Hlavní Účetní Kniha,
+View Leads,Zobrazit Vodítka,
+Attribute Value,Hodnota atributu,
+"Email id must be unique, already exists for {0}","E-mail id musí být jedinečný, již existuje {0}"
+Itemwise Recommended Reorder Level,Itemwise Doporučené Změna pořadí Level,
+Please select {0} first,"Prosím, nejprve vyberte {0} "
+To get Item Group in details table,Chcete-li získat položku Group v tabulce Rozpis,
+Redrawing,Překreslens,
+Etching,Lept,
+Commission,Provize,
+You are not allowed to reply to this ticket.,Nejste oprávnění odpovědět na tento lístek.
+"<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 -%}
@@ -3416,486 +3416,486 @@
  {% v případě, fax%} Fax: {{fax}} & lt; br & gt; {% endif -%} 
  {%, pokud email_id%} E-mail: {{email_id}} & lt; br & gt ; {% endif -%} 
  </ code> </ pre>"
-DocType: Salary Slip Deduction,Default Amount,Výchozí částka
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +84,Warehouse not found in the system,Sklad nebyl nalezen v systému
-DocType: Quality Inspection Reading,Quality Inspection Reading,Kvalita Kontrola Reading
-DocType: Party Account,col_break1,col_break1
-apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +26,`Freeze Stocks Older Than` should be smaller than %d days.,`Zmrazit Zásoby Starší Vic jak` by měla být menší než %d dnů.
-,Project wise Stock Tracking,Sledování zboží dle projektu
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +176,Maintenance Schedule {0} exists against {0},Plán údržby {0} existuje na {0}
-DocType: Stock Entry Detail,Actual Qty (at source/target),Skutečné množství (u zdroje/cíle)
-DocType: Item Customer Detail,Ref Code,Ref Code
-apps/erpnext/erpnext/config/hr.py +13,Employee records.,Zaměstnanecké záznamy.
-DocType: HR Settings,Payroll Settings,Nastavení Mzdové
-apps/erpnext/erpnext/config/accounts.py +58,Match non-linked Invoices and Payments.,Zápas Nepropojený fakturách a platbách.
-DocType: Email Digest,New Purchase Orders,Nové vydané objednávky
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22,Root cannot have a parent cost center,Root nemůže mít rodič nákladové středisko
-DocType: Sales Invoice,C-Form Applicable,C-Form Použitelné
-DocType: UOM Conversion Detail,UOM Conversion Detail,UOM konverze Detail
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +476,Keep it web friendly 900px (w) by 100px (h),Keep It webové přátelské 900px (w) o 100px (h)
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +44,Charges are updated in Purchase Receipt against each item,Poplatky jsou aktualizovány v dokladu o koupi na každou položku
-DocType: Payment Tool,Get Outstanding Vouchers,Získejte Vynikající poukazy
-DocType: Warranty Claim,Resolved By,Vyřešena
-DocType: Appraisal,Start Date,Datum zahájení
-sites/assets/js/desk.min.js +512,Value,Hodnota
-apps/erpnext/erpnext/config/hr.py +130,Allocate leaves for a period.,Přidělit listy dobu.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +39,Account {0}: You can not assign itself as parent account,Účet {0}: nelze přiřadit sebe jako nadřazený účet
-DocType: Purchase Invoice Item,Price List Rate,Ceník Rate
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +166,Delivered Serial No {0} cannot be deleted,Dodává Pořadové číslo {0} nemůže být smazán
-DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Zobrazit ""Skladem"" nebo ""Není skladem"" na základě skladem k dispozici v tomto skladu."
-apps/erpnext/erpnext/config/manufacturing.py +13,Bill of Materials (BOM),Bill of Materials (BOM)
-DocType: Time Log,Hours,Hodiny
-DocType: Project,Expected Start Date,Očekávané datum zahájení
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +37,Rolling,Rolling
-DocType: ToDo,Priority,Priorita
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +168,"Cannot delete Serial No {0} in stock. First remove from stock, then delete.","Nelze smazat sériové číslo {0} na skladě. Nejprve odstraňte ze skladu, a pak smažte."
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +41,Remove item if charges is not applicable to that item,Odebrat pokud poplatků není pro tuto položku
-DocType: Backup Manager,Dropbox Access Allowed,Dropbox Přístup povolen
-DocType: Backup Manager,Weekly,Týdenní
-DocType: SMS Settings,Eg. smsgateway.com/api/send_sms.cgi,Např. smsgateway.com/api/send-sms.cgi
-DocType: Maintenance Visit,Fully Completed,Plně Dokončeno
-DocType: Item,"Products will be sorted by weight-age in default searches. More the weight-age, higher the product will appear in the list.","Produkty budou rozděleny dle hmotnosti věku ve výchozím vyhledávání. Více váha věku, bude vyšší výrobek objeví v seznamu."
-apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}% Hotovo
-DocType: Employee,Educational Qualification,Vzdělávací Kvalifikace
-DocType: Workstation,Operating Costs,Provozní náklady
-DocType: Employee Leave Approver,Employee Leave Approver,Zaměstnanec Leave schvalovač
-apps/erpnext/erpnext/templates/includes/footer_extension.html +9,Stay Updated,Zůstaňte Aktualizováno
-apps/erpnext/erpnext/stock/doctype/item/item.py +376,Row {0}: An Reorder entry already exists for this warehouse {1},Row {0}: Položka Změna pořadí již pro tento sklad existuje {1}
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +66,"Cannot declare as lost, because Quotation has been made.","Nelze prohlásit za ztracený, protože citace byla provedena."
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +132,Electron beam machining,Paprsek obrábění Electron
-DocType: Purchase Taxes and Charges Template,Purchase Master Manager,Nákup Hlavní manažer
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +468,Production Order {0} must be submitted,Výrobní zakázka {0} musí být předloženy
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +160,Please select Start Date and End Date for Item {0},"Prosím, vyberte Počáteční datum a koncové datum pro položku {0}"
-apps/erpnext/erpnext/config/stock.py +141,Main Reports,Hlavní zprávy
-apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +73,Stock Ledger entries balances updated,Sklad Ledger položky bilancí aktualizováno
-apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,K dnešnímu dni nemůže být dříve od data
-DocType: Purchase Receipt Item,Prevdoc DocType,Prevdoc DOCTYPE
-apps/erpnext/erpnext/stock/doctype/item/item.js +201,Add / Edit Prices,Přidat / Upravit ceny
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +54,Chart of Cost Centers,Diagram nákladových středisek
-,Requested Items To Be Ordered,Požadované položky je třeba objednat
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +238,My Orders,Moje objednávky
-DocType: Price List,Price List Name,Ceník Jméno
-DocType: Time Log,For Manufacturing,Pro výrobu
-DocType: BOM,Manufacturing,Výroba
-,Ordered Items To Be Delivered,"Objednané zboží, které mají být dodány"
-DocType: Account,Income,Příjem
-,Setup Wizard,Průvodce nastavením
-DocType: Industry Type,Industry Type,Typ Průmyslu
-apps/erpnext/erpnext/templates/includes/cart.js +264,Something went wrong!,Něco se pokazilo!
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +68,Warning: Leave application contains following block dates,Upozornění: Nechte Aplikace obsahuje následující data bloku
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +235,Sales Invoice {0} has already been submitted,Prodejní faktury {0} již byla odeslána
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Completion Date,Dokončení Datum
-DocType: Purchase Invoice Item,Amount (Company Currency),Částka (Měna Společnosti)
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +9,Die casting,Die lití
-DocType: Email Alert,Reference Date,Referenční data
-apps/erpnext/erpnext/config/hr.py +105,Organization unit (department) master.,Organizace jednotka (departement) master.
-apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +25,Please enter valid mobile nos,Zadejte platné mobilní nos
-DocType: Email Digest,User Specific,Uživatel Specifické
-DocType: Budget Detail,Budget Detail,Detail Rozpočtu
-apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +73,Please enter message before sending,"Prosím, zadejte zprávu před odesláním"
-DocType: Communication,Status,Stav
-apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +36,Stock UOM updated for Item {0},Sklad UOM aktualizovaný k bodu {0}
-DocType: Company History,Year,Rok
-apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +69,Please Update SMS Settings,Aktualizujte prosím nastavení SMS
-apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.py +34,Time Log {0} already billed,Time Log {0} již účtoval
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +176,Unsecured Loans,Nezajištěných úvěrů
-DocType: Cost Center,Cost Center Name,Jméno nákladového střediska
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Item {0} with Serial No {1} is already installed,Položka {0} s Serial č {1} je již nainstalován
-apps/erpnext/erpnext/setup/doctype/backup_manager/backup_manager.js +10,You can start by selecting backup frequency and granting access for sync,Můžete začít výběrem frekvence zálohování a poskytnutím přístupu pro synchronizaci
-DocType: Maintenance Schedule Detail,Scheduled Date,Plánované datum
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +69,Total Paid Amt,Celkem uhrazeno Amt
-DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Zprávy větší než 160 znaků bude rozdělena do více zpráv
-DocType: Purchase Receipt Item,Received and Accepted,Přijaté a Přijato
-DocType: Item Attribute,"Lower the number, higher the priority in the Item Code suffix that will be created for this Item Attribute for the Item Variant","Nižší číslo, vyšší prioritu v položce kódu příponu, který bude vytvořen pro tuto položku atribut výtisku Variant"
-,Serial No Service Contract Expiry,Pořadové číslo Servisní smlouva vypršení platnosti
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +79,Employee can not be changed,Zaměstnanec nemůže být změněn
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +257,You cannot credit and debit same account at the same time,Nemůžete dělat kreditní a debetní záznam na stejný účet ve stejnou dobu.
-DocType: Naming Series,Help HTML,Nápověda HTML
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +50,Total weightage assigned should be 100%. It is {0},Celková weightage přiřazen by měla být 100%. Je {0}
-apps/erpnext/erpnext/controllers/status_updater.py +100,Allowance for over-{0} crossed for Item {1},Příspěvek na nadměrné {0} přešel k bodu {1}
-DocType: Address,Name of person or organization that this address belongs to.,"Jméno osoby nebo organizace, která tato adresa patří."
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +536,Your Suppliers,Vaši Dodavatelé
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +62,Cannot set as Lost as Sales Order is made.,"Nelze nastavit jako Ztraceno, protože je přijata objednávka."
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +58,Another Salary Structure {0} is active for employee {1}. Please make its status 'Inactive' to proceed.,"Další platovou strukturu {0} je aktivní pro zaměstnance {1}. Prosím, aby jeho stav ""neaktivní"" pokračovat."
-DocType: Purchase Invoice,Contact,Kontakt
-DocType: Features Setup,Exports,Vývoz
-DocType: Lead,Converted,Převedené
-DocType: Item,Has Serial No,Má Sériové číslo
-DocType: Employee,Date of Issue,Datum vydání
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +16,{0}: From {0} for {1},{0}: Od {0} do {1}
-DocType: Issue,Content Type,Typ obsahu
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +16,Computer,Počítač
-DocType: Item,List this Item in multiple groups on the website.,Seznam tuto položku ve více skupinách na internetových stránkách.
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +62,Item: {0} does not exist in the system,Položka: {0} neexistuje v systému
-apps/erpnext/erpnext/accounts/doctype/account/account.py +63,You are not authorized to set Frozen value,Nejste oprávněni stanovit hodnotu Zmražení
-DocType: Payment Reconciliation,Get Unreconciled Entries,Získat smířit záznamů
-DocType: Purchase Receipt,Date on which lorry started from supplier warehouse,"Ode dne, kdy začal nákladního vozidla od dodavatele skladu"
-DocType: Cost Center,Budgets,Rozpočty
-apps/frappe/frappe/core/page/modules_setup/modules_setup.py +11,Updated,Aktualizováno
-DocType: Employee,Emergency Contact Details,Nouzové kontaktní údaje
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +394,What does it do?,Co to dělá?
-DocType: Delivery Note,To Warehouse,Do skladu
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +56,Account {0} has been entered more than once for fiscal year {1},Účet {0} byl zadán více než jednou za fiskální rok {1}
-,Average Commission Rate,Průměrná cena Komise
-apps/erpnext/erpnext/stock/doctype/item/item.py +298,'Has Serial No' can not be 'Yes' for non-stock item,"""Má sériové číslo"", nemůže být ""ano"" pro neskladové zboží"
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +34,Attendance can not be marked for future dates,Účast nemůže být označen pro budoucí data
-DocType: Pricing Rule,Pricing Rule Help,Ceny Pravidlo Help
-DocType: Purchase Taxes and Charges,Account Head,Účet Head
-DocType: Price List,"Specify a list of Territories, for which, this Price List is valid","Zadejte seznam území, pro které tato Ceník je platný"
-apps/erpnext/erpnext/config/stock.py +79,Update additional costs to calculate landed cost of items,Aktualizace dodatečné náklady pro výpočet vyložené náklady položek
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +106,Electrical,Elektrický
-DocType: Stock Entry,Total Value Difference (Out - In),Celková hodnota Rozdíl (Out - In)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +94,Difference Account mandatory for purpose '{0}',Rozdíl Účet povinné pro účely &#39;{0}&#39;
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,User ID not set for Employee {0},User ID není nastavena pro zaměstnance {0}
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +71,Peening,Peening
-apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.js +30,From Warranty Claim,Od reklamačnímu
-DocType: Stock Entry,Default Source Warehouse,Výchozí zdroj Warehouse
-DocType: Item,Customer Code,Code zákazníků
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +203,Birthday Reminder for {0},Narozeninová připomínka pro {0}
-DocType: Item,Default Purchase Account in which cost of the item will be debited.,"Default Nákup účet, na němž se bude zatížen náklady na položky."
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +162,Lapping,Zabrušovací
-apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.js +8,Days Since Last Order,Počet dnů od poslední objednávky
-DocType: Buying Settings,Naming Series,Číselné řady
-DocType: Leave Block List,Leave Block List Name,Nechte Jméno Block List
-DocType: User,Enabled,Zapnuto
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Stock Aktiva
-apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.js +22,Do you really want to Submit all Salary Slip for month {0} and year {1},"Opravdu chcete, aby předložila všechny výplatní pásce za měsíc {0} a rok {1}"
-apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +8,Import Subscribers,Importovat Odběratelé
-DocType: Target Detail,Target Qty,Target Množství
-DocType: Attendance,Present,Současnost
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +35,Delivery Note {0} must not be submitted,Delivery Note {0} nesmí být předloženy
-DocType: Notification Control,Sales Invoice Message,Prodejní faktury Message
-DocType: Email Digest,Income Booked,Rezervováno příjmů
-DocType: Authorization Rule,Based On,Založeno na
-,Ordered Qty,Objednáno Množství
-DocType: Stock Settings,Stock Frozen Upto,Reklamní Frozen aľ
-apps/erpnext/erpnext/config/projects.py +13,Project activity / task.,Projektová činnost / úkol.
-apps/erpnext/erpnext/config/hr.py +65,Generate Salary Slips,Generování výplatních páskách
-apps/frappe/frappe/utils/__init__.py +85,{0} is not a valid email id,{0} není platné id emailu
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41,"Buying must be checked, if Applicable For is selected as {0}","Nákup musí být zkontrolováno, v případě potřeby pro vybrán jako {0}"
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,Sleva musí být menší než 100
-DocType: ToDo,Low,Nízké
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +70,Spinning,Spinning
-DocType: Landed Cost Voucher,Landed Cost Voucher,Přistálo Náklady Voucher
-apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.py +55,Please set {0},Prosím nastavte {0}
-DocType: Purchase Invoice,Repeat on Day of Month,Opakujte na den v měsíci
-DocType: Employee,Health Details,Zdravotní Podrobnosti
-DocType: Offer Letter,Offer Letter Terms,Nabídka Letter Podmínky
-DocType: Features Setup,To track any installation or commissioning related work after sales,Chcete-li sledovat jakékoli zařízení nebo uvedení do provozu souvisejících s prací po prodeji
-DocType: Project,Estimated Costing,Odhadovaná kalkulace
-DocType: Purchase Invoice Advance,Journal Entry Detail No,Zápis do deníku Detail No
-DocType: Employee External Work History,Salary,Plat
-DocType: Serial No,Delivery Document Type,Dodávka Typ dokumentu
-DocType: Salary Manager,Submit all salary slips for the above selected criteria,Odeslat všechny výplatní pásky pro výše zvolených kritérií
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +93,{0} Items synced,{0} položky synchronizovány
-DocType: Sales Order,Partly Delivered,Částečně vyhlášeno
-DocType: Sales Invoice,Existing Customer,Stávající zákazník
-DocType: Email Digest,Receivables,Pohledávky
-DocType: Quality Inspection Reading,Reading 5,Čtení 5
-DocType: Purchase Order,"Enter email id separated by commas, order will be mailed automatically on particular date","Zadejte e-mail id odděleny čárkami, bude objednávka bude zaslán automaticky na určité datum"
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +37,Campaign Name is required,Je zapotřebí Název kampaně
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,Rounded Off,Zaokrouhleno
-DocType: Maintenance Visit,Maintenance Date,Datum údržby
-DocType: Purchase Receipt Item,Rejected Serial No,Zamítnuto Serial No
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +50,Deep drawing,Hluboké tažení
-apps/erpnext/erpnext/selling/doctype/sales_bom/sales_bom.js +13,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Sales BOM","Prosím, vyberte položku, kde ""je skladem"", je ""Ne"" a ""Je Sales Item"" ""Ano"" a není tam žádný jiný Sales BOM"
-apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +40,New Newsletter,New Newsletter
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +167,Start date should be less than end date for Item {0},Datum zahájení by měla být menší než konečné datum pro bod {0}
-apps/erpnext/erpnext/stock/doctype/item/item.js +46,Show Balance,Show Balance
-DocType: Item,"Example: ABCD.#####
+Default Amount,Výchozí částka,
+Warehouse not found in the system,Sklad nebyl nalezen v systému,
+Quality Inspection Reading,Kvalita Kontrola Reading,
+col_break1,col_break1,
+`Freeze Stocks Older Than` should be smaller than %d days.,`Zmrazit Zásoby Starší Vic jak` by měla být menší než %d dnů.
+Project wise Stock Tracking,Sledování zboží dle projektu,
+Maintenance Schedule {0} exists against {0},Plán údržby {0} existuje na {0}
+Actual Qty (at source/target),Skutečné množství (u zdroje/cíle)
+Ref Code,Ref Code,
+Employee records.,Zaměstnanecké záznamy.
+Payroll Settings,Nastavení Mzdov$1,
+Match non-linked Invoices and Payments.,Zápas Nepropojený fakturách a platbách.
+New Purchase Orders,Nové vydané objednávky,
+Root cannot have a parent cost center,Root nemůže mít rodič nákladové středisko,
+C-Form Applicable,C-Form Použitelny,
+UOM Conversion Detail,UOM konverze Detail,
+Keep it web friendly 900px (w) by 100px (h),Keep It webové přátelské 900px (w) o 100px (h)
+Charges are updated in Purchase Receipt against each item,Poplatky jsou aktualizovány v dokladu o koupi na každou položku,
+Get Outstanding Vouchers,Získejte Vynikající poukazy,
+Resolved By,Vyřešena,
+Start Date,Datum zahájenu,
+Value,Hodnota,
+Allocate leaves for a period.,Přidělit listy dobu.
+Account {0}: You can not assign itself as parent account,Účet {0}: nelze přiřadit sebe jako nadřazený účet,
+Price List Rate,Ceník Rate,
+Delivered Serial No {0} cannot be deleted,Dodává Pořadové číslo {0} nemůže být smazán,
+"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Zobrazit ""Skladem"" nebo ""Není skladem"" na základě skladem k dispozici v tomto skladu."
+Bill of Materials (BOM),Bill of Materials (BOM)
+Hours,Hodiny,
+Expected Start Date,Očekávané datum zahájeny,
+Rolling,Rolling,
+Priority,Priorita,
+"Cannot delete Serial No {0} in stock. First remove from stock, then delete.","Nelze smazat sériové číslo {0} na skladě. Nejprve odstraňte ze skladu, a pak smažte."
+Remove item if charges is not applicable to that item,Odebrat pokud poplatků není pro tuto položku,
+Dropbox Access Allowed,Dropbox Přístup povolen,
+Weekly,Týdennu,
+Eg. smsgateway.com/api/send_sms.cgi,Např. smsgateway.com/api/send-sms.cgi,
+Fully Completed,Plně Dokončeno,
+"Products will be sorted by weight-age in default searches. More the weight-age, higher the product will appear in the list.","Produkty budou rozděleny dle hmotnosti věku ve výchozím vyhledávání. Více váha věku, bude vyšší výrobek objeví v seznamu."
+{0}% Complete,{0}% Hotovo,
+Educational Qualification,Vzdělávací Kvalifikace,
+Operating Costs,Provozní náklady,
+Employee Leave Approver,Zaměstnanec Leave schvalovao,
+Stay Updated,Zůstaňte Aktualizováno,
+Row {0}: An Reorder entry already exists for this warehouse {1},Row {0}: Položka Změna pořadí již pro tento sklad existuje {1}
+"Cannot declare as lost, because Quotation has been made.","Nelze prohlásit za ztracený, protože citace byla provedena."
+Electron beam machining,Paprsek obrábění Electron,
+Purchase Master Manager,Nákup Hlavní manažer,
+Production Order {0} must be submitted,Výrobní zakázka {0} musí být předloženy,
+Please select Start Date and End Date for Item {0},"Prosím, vyberte Počáteční datum a koncové datum pro položku {0}"
+Main Reports,Hlavní zprávy,
+Stock Ledger entries balances updated,Sklad Ledger položky bilancí aktualizováno,
+To date cannot be before from date,K dnešnímu dni nemůže být dříve od data,
+Prevdoc DocType,Prevdoc DOCTYPE,
+Add / Edit Prices,Přidat / Upravit ceny,
+Chart of Cost Centers,Diagram nákladových středisek,
+Requested Items To Be Ordered,Požadované položky je třeba objednat,
+My Orders,Moje objednávky,
+Price List Name,Ceník Jméno,
+For Manufacturing,Pro výrobu,
+Manufacturing,Výroba,
+Ordered Items To Be Delivered,"Objednané zboží, které mají být dodány"
+Income,Příjem,
+Setup Wizard,Průvodce nastavením,
+Industry Type,Typ Průmyslu,
+Something went wrong!,Něco se pokazilo!
+Warning: Leave application contains following block dates,Upozornění: Nechte Aplikace obsahuje následující data bloku,
+Sales Invoice {0} has already been submitted,Prodejní faktury {0} již byla odeslána,
+Completion Date,Dokončení Datum,
+Amount (Company Currency),Částka (Měna Společnosti)
+Die casting,Die lita,
+Reference Date,Referenční data,
+Organization unit (department) master.,Organizace jednotka (departement) master.
+Please enter valid mobile nos,Zadejte platné mobilní nos,
+User Specific,Uživatel Specificks,
+Budget Detail,Detail Rozpočtu,
+Please enter message before sending,"Prosím, zadejte zprávu před odesláním"
+Status,Stav,
+Stock UOM updated for Item {0},Sklad UOM aktualizovaný k bodu {0}
+Year,Rok,
+Please Update SMS Settings,Aktualizujte prosím nastavení SMS,
+Time Log {0} already billed,Time Log {0} již účtoval,
+Unsecured Loans,Nezajištěných úvěrk,
+Cost Center Name,Jméno nákladového střediska,
+Item {0} with Serial No {1} is already installed,Položka {0} s Serial č {1} je již nainstalován,
+You can start by selecting backup frequency and granting access for sync,Můžete začít výběrem frekvence zálohování a poskytnutím přístupu pro synchronizaci,
+Scheduled Date,Plánované datum,
+Total Paid Amt,Celkem uhrazeno Amt,
+Messages greater than 160 characters will be split into multiple messages,Zprávy větší než 160 znaků bude rozdělena do více zpráv,
+Received and Accepted,Přijaté a Přijato,
+"Lower the number, higher the priority in the Item Code suffix that will be created for this Item Attribute for the Item Variant","Nižší číslo, vyšší prioritu v položce kódu příponu, který bude vytvořen pro tuto položku atribut výtisku Variant"
+Serial No Service Contract Expiry,Pořadové číslo Servisní smlouva vypršení platnosti,
+Employee can not be changed,Zaměstnanec nemůže být změněn,
+You cannot credit and debit same account at the same time,Nemůžete dělat kreditní a debetní záznam na stejný účet ve stejnou dobu.
+Help HTML,Nápověda HTML,
+Total weightage assigned should be 100%. It is {0},Celková weightage přiřazen by měla být 100%. Je {0}
+Allowance for over-{0} crossed for Item {1},Příspěvek na nadměrné {0} přešel k bodu {1}
+Name of person or organization that this address belongs to.,"Jméno osoby nebo organizace, která tato adresa patří."
+Your Suppliers,Vaši Dodavatel$1,
+Cannot set as Lost as Sales Order is made.,"Nelze nastavit jako Ztraceno, protože je přijata objednávka."
+Another Salary Structure {0} is active for employee {1}. Please make its status 'Inactive' to proceed.,"Další platovou strukturu {0} je aktivní pro zaměstnance {1}. Prosím, aby jeho stav ""neaktivní"" pokračovat."
+Contact,Kontakt,
+Exports,Vývoz,
+Converted,Převedent,
+Has Serial No,Má Sériové číslo,
+Date of Issue,Datum vydánt,
+{0}: From {0} for {1},{0}: Od {0} do {1}
+Content Type,Typ obsahu,
+Computer,Počítau,
+List this Item in multiple groups on the website.,Seznam tuto položku ve více skupinách na internetových stránkách.
+Item: {0} does not exist in the system,Položka: {0} neexistuje v systému,
+You are not authorized to set Frozen value,Nejste oprávněni stanovit hodnotu Zmraženu,
+Get Unreconciled Entries,Získat smířit záznamu,
+Date on which lorry started from supplier warehouse,"Ode dne, kdy začal nákladního vozidla od dodavatele skladu"
+Budgets,Rozpočty,
+Updated,Aktualizováno,
+Emergency Contact Details,Nouzové kontaktní údaje,
+What does it do?,Co to dělá?
+To Warehouse,Do skladu,
+Account {0} has been entered more than once for fiscal year {1},Účet {0} byl zadán více než jednou za fiskální rok {1}
+Average Commission Rate,Průměrná cena Komise,
+'Has Serial No' can not be 'Yes' for non-stock item,"""Má sériové číslo"", nemůže být ""ano"" pro neskladové zboží"
+Attendance can not be marked for future dates,Účast nemůže být označen pro budoucí data,
+Pricing Rule Help,Ceny Pravidlo Help,
+Account Head,Účet Head,
+"Specify a list of Territories, for which, this Price List is valid","Zadejte seznam území, pro které tato Ceník je platný"
+Update additional costs to calculate landed cost of items,Aktualizace dodatečné náklady pro výpočet vyložené náklady položek,
+Electrical,Elektrickk,
+Total Value Difference (Out - In),Celková hodnota Rozdíl (Out - In)
+Difference Account mandatory for purpose '{0}',Rozdíl Účet povinné pro účely &#39;{0}&#39;
+User ID not set for Employee {0},User ID není nastavena pro zaměstnance {0}
+Peening,Peening,
+From Warranty Claim,Od reklamačnímu,
+Default Source Warehouse,Výchozí zdroj Warehouse,
+Customer Code,Code zákazníkg,
+Birthday Reminder for {0},Narozeninová připomínka pro {0}
+Default Purchase Account in which cost of the item will be debited.,"Default Nákup účet, na němž se bude zatížen náklady na položky."
+Lapping,Zabrušovacy,
+Days Since Last Order,Počet dnů od poslední objednávky,
+Naming Series,Číselné řady,
+Leave Block List Name,Nechte Jméno Block List,
+Enabled,Zapnuto,
+Stock Assets,Stock Aktiva,
+Do you really want to Submit all Salary Slip for month {0} and year {1},"Opravdu chcete, aby předložila všechny výplatní pásce za měsíc {0} a rok {1}"
+Import Subscribers,Importovat Odběratelt,
+Target Qty,Target Množstvt,
+Present,Současnost,
+Delivery Note {0} must not be submitted,Delivery Note {0} nesmí být předloženy,
+Sales Invoice Message,Prodejní faktury Message,
+Income Booked,Rezervováno příjmt,
+Based On,Založeno na,
+Ordered Qty,Objednáno Množstvt,
+Stock Frozen Upto,Reklamní Frozen at,
+Project activity / task.,Projektová činnost / úkol.
+Generate Salary Slips,Generování výplatních páskách,
+{0} is not a valid email id,{0} není platné id emailu,
+"Buying must be checked, if Applicable For is selected as {0}","Nákup musí být zkontrolováno, v případě potřeby pro vybrán jako {0}"
+Discount must be less than 100,Sleva musí být menší než 100,
+Low,Nízk0,
+Spinning,Spinning,
+Landed Cost Voucher,Přistálo Náklady Voucher,
+Please set {0},Prosím nastavte {0}
+Repeat on Day of Month,Opakujte na den v měsíci,
+Health Details,Zdravotní Podrobnosti,
+Offer Letter Terms,Nabídka Letter Podmínky,
+To track any installation or commissioning related work after sales,Chcete-li sledovat jakékoli zařízení nebo uvedení do provozu souvisejících s prací po prodeji,
+Estimated Costing,Odhadovaná kalkulace,
+Journal Entry Detail No,Zápis do deníku Detail No,
+Salary,Plat,
+Delivery Document Type,Dodávka Typ dokumentu,
+Submit all salary slips for the above selected criteria,Odeslat všechny výplatní pásky pro výše zvolených kritérii,
+{0} Items synced,{0} položky synchronizovány,
+Partly Delivered,Částečně vyhlášeno,
+Existing Customer,Stávající zákazník,
+Receivables,Pohledávky,
+Reading 5,Čtení 5,
+"Enter email id separated by commas, order will be mailed automatically on particular date","Zadejte e-mail id odděleny čárkami, bude objednávka bude zaslán automaticky na určité datum"
+Campaign Name is required,Je zapotřebí Název kampano,
+Rounded Off,Zaokrouhleno,
+Maintenance Date,Datum údržby,
+Rejected Serial No,Zamítnuto Serial No,
+Deep drawing,Hluboké taženo,
+"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Sales BOM","Prosím, vyberte položku, kde ""je skladem"", je ""Ne"" a ""Je Sales Item"" ""Ano"" a není tam žádný jiný Sales BOM"
+New Newsletter,New Newsletter,
+Start date should be less than end date for Item {0},Datum zahájení by měla být menší než konečné datum pro bod {0}
+Show Balance,Show Balance,
+"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.","Příklad:. ABCD ##### 
  Je-li série nastavuje a pořadové číslo není uvedeno v transakcích, bude vytvořen poté automaticky sériové číslo na základě této série. Pokud chcete vždy výslovně uvést pořadová čísla pro tuto položku. ponechte prázdné."
-DocType: Upload Attendance,Upload Attendance,Nahrát Návštěvnost
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +143,BOM and Manufacturing Quantity are required,BOM a výroba množství jsou povinné
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Stárnutí rozsah 2
-DocType: Journal Entry Account,Amount,Částka
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +146,Riveting,Nýtování
-apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +21,BOM replaced,BOM nahradil
-,Sales Analytics,Prodejní Analytics
-DocType: Manufacturing Settings,Manufacturing Settings,Výrobní nastavení
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,Please enter default currency in Company Master,Zadejte prosím výchozí měnu v podniku Mistr
-DocType: Stock Entry Detail,Stock Entry Detail,Reklamní Entry Detail
-apps/erpnext/erpnext/templates/includes/cart.js +286,You need to be logged in to view your cart.,Musíte být přihlášen k zobrazení košíku.
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +200,New Account Name,Nový název účtu
-DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Dodává se nákladů na suroviny
-DocType: Selling Settings,Settings for Selling Module,Nastavení pro prodej Module
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +68,Customer Service,Služby zákazníkům
-DocType: Item Customer Detail,Item Customer Detail,Položka Detail Zákazník
-apps/erpnext/erpnext/config/hr.py +53,Offer candidate a Job.,Nabídka kandidát Job.
-DocType: Notification Control,Prompt for Email on Submission of,Výzva pro e-mail na předkládání
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +61,Item {0} must be a stock Item,Položka {0} musí být skladem
-apps/erpnext/erpnext/config/accounts.py +102,Default settings for accounting transactions.,Výchozí nastavení účetních transakcí.
-apps/frappe/frappe/model/naming.py +40,{0} is required,{0} je vyžadováno
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +20,Vacuum molding,Vakuové tváření
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +57,Expected Date cannot be before Material Request Date,Očekávané datum nemůže být před Materiál Poptávka Datum
-DocType: Contact Us Settings,City,Město
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +131,Ultrasonic machining,Ultrazvukové obrábění
-apps/erpnext/erpnext/stock/get_item_details.py +126,Item {0} must be a Sales Item,Bod {0} musí být prodejní položky
-DocType: Naming Series,Update Series Number,Aktualizace Series Number
-DocType: Account,Equity,Hodnota majetku
-DocType: Task,Closing Date,Uzávěrka Datum
-DocType: Sales Order Item,Produced Quantity,Produkoval Množství
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +79,Engineer,Inženýr
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +329,Item Code required at Row No {0},Kód položky třeba na řádku č {0}
-DocType: Sales Partner,Partner Type,Partner Type
-DocType: Purchase Taxes and Charges,Actual,Aktuální
-DocType: Purchase Order,% of materials received against this Purchase Order,% materiálů přijatých proti této objednávce
-DocType: Authorization Rule,Customerwise Discount,Sleva podle zákazníka
-DocType: Purchase Invoice,Against Expense Account,Proti výdajového účtu
-DocType: Production Order,Production Order,Výrobní Objednávka
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +242,Installation Note {0} has already been submitted,Poznámka k instalaci {0} již byla odeslána
-DocType: Quotation Item,Against Docname,Proti Docname
-DocType: SMS Center,All Employee (Active),Všichni zaměstnanci (Aktivní)
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9,View Now,Zobrazit nyní
-DocType: Purchase Invoice,Select the period when the invoice will be generated automatically,"Vyberte období, kdy faktura budou generovány automaticky"
-DocType: BOM,Raw Material Cost,Cena surovin
-DocType: Item Reorder,Re-Order Level,Re-Order Level
-DocType: Production Planning Tool,Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,"Zadejte položky a plánované ks, pro které chcete získat zakázky na výrobu, nebo stáhnout suroviny pro analýzu."
-sites/assets/js/list.min.js +160,Gantt Chart,Pruhový diagram
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +52,Part-time,Part-time
-DocType: Employee,Applicable Holiday List,Použitelný Seznam Svátků
-DocType: Employee,Cheque,Šek
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +52,Series Updated,Řada Aktualizováno
-apps/erpnext/erpnext/accounts/doctype/account/account.py +105,Report Type is mandatory,Report Type je povinné
-DocType: Item,Serial Number Series,Sériové číslo Series
-apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +67,Warehouse is mandatory for stock Item {0} in row {1},Sklad je povinný pro skladovou položku {0} na řádku {1}
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +44,Retail & Wholesale,Maloobchod a velkoobchod
-DocType: Issue,First Responded On,Prvně odpovězeno dne
-DocType: Website Item Group,Cross Listing of Item in multiple groups,Cross Výpis zboží v několika skupinách
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +349,The First User: You,První Uživatel: Vy
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +48,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Datum zahájení a  Datum ukončení Fiskálního roku jsou již stanoveny ve fiskálním roce {0}
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +161,Successfully Reconciled,Úspěšně smířeni
-DocType: Production Order,Planned End Date,Plánované datum ukončení
-apps/erpnext/erpnext/config/stock.py +43,Where items are stored.,"Tam, kde jsou uloženy předměty."
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +19,Invoiced Amount,Fakturovaná částka
-DocType: Attendance,Attendance,Účast
-DocType: Page,No,Ne
-DocType: BOM,Materials,Materiály
-DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Pokud není zatrženo, seznam bude muset být přidány ke každé oddělení, kde má být použit."
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +663,Make Delivery,Proveďte Dodávka
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +261,Posting date and posting time is mandatory,Datum a čas zadání je povinný
-apps/erpnext/erpnext/config/buying.py +79,Tax template for buying transactions.,Daňové šablona pro nákup transakcí.
-,Item Prices,Ceny Položek
-DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,"Ve slovech budou viditelné, jakmile uložíte objednávce."
-DocType: Period Closing Voucher,Period Closing Voucher,Období Uzávěrka Voucher
-apps/erpnext/erpnext/config/stock.py +125,Price List master.,Ceník master.
-DocType: Task,Review Date,Review Datum
-DocType: DocPerm,Level,Úroveň
-DocType: Purchase Taxes and Charges,On Net Total,On Net Celkem
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +176,Target warehouse in row {0} must be same as Production Order,Target sklad v řádku {0} musí být stejná jako výrobní zakázky
-apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +61,No permission to use Payment Tool,Nemáte oprávnění k použití platební nástroj
-apps/erpnext/erpnext/controllers/recurring_document.py +191,'Notification Email Addresses' not specified for recurring %s,"""E-mailové adresy pro Oznámení"", které nejsou uvedeny na opakující se %s"
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +85,Milling,Frézování
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +59,Nibbling,Okusování
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +84,Administrative Expenses,Administrativní náklady
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +17,Consulting,Consulting
-DocType: Customer Group,Parent Customer Group,Parent Customer Group
-sites/assets/js/erpnext.min.js +45,Change,Změna
-DocType: Purchase Invoice,Contact Email,Kontaktní e-mail
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +103,Purchase Order {0} is 'Stopped',Vydaná objednávka {0} je 'Zastavena'
-DocType: Appraisal Goal,Score Earned,Skóre Zasloužené
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +391,"e.g. ""My Company LLC""","např ""My Company LLC """
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +168,Notice Period,Výpovědní Lhůta
-DocType: Bank Reconciliation Detail,Voucher ID,Voucher ID
-apps/erpnext/erpnext/setup/doctype/territory/territory.js +14,This is a root territory and cannot be edited.,To je kořen území a nelze upravovat.
-DocType: Packing Slip,Gross Weight UOM,Hrubá Hmotnost UOM
-DocType: Email Digest,Receivables / Payables,Pohledávky / Závazky
-DocType: Journal Entry Account,Against Sales Invoice,Proti prodejní faktuře
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +62,Stamping,Lisování
-DocType: Landed Cost Item,Landed Cost Item,Přistálo nákladovou položkou
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +56,Show zero values,Ukázat nulové hodnoty
-DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Množství položky získané po výrobě / přebalení z daných množství surovin
-DocType: Payment Reconciliation,Receivable / Payable Account,Pohledávky / závazky účet
-DocType: Delivery Note Item,Against Sales Order Item,Proti položce přijaté objednávky
-DocType: Item,Default Warehouse,Výchozí Warehouse
-DocType: Task,Actual End Date (via Time Logs),Skutečné Datum ukončení (přes Time Záznamy)
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +20,Please enter parent cost center,"Prosím, zadejte nákladové středisko mateřský"
-DocType: Delivery Note,Print Without Amount,Tisknout bez Částka
-apps/erpnext/erpnext/controllers/buying_controller.py +70,Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,"Daň z kategorie nemůže být ""Ocenění"" nebo ""Ocenění a celkový"", protože všechny položky jsou běžně skladem"
-DocType: User,Last Name,Příjmení
-DocType: Web Page,Left,Vlevo
-DocType: Event,All Day,Celý den
-DocType: Communication,Support Team,Tým podpory
-DocType: Appraisal,Total Score (Out of 5),Celkové skóre (Out of 5)
-DocType: Contact Us Settings,State,Stav
-DocType: Batch,Batch,Šarže
-apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +48,Balance,Zůstatek
-DocType: Project,Total Expense Claim (via Expense Claims),Total Expense Claim (via Expense nároků)
-DocType: User,Gender,Pohlaví
-DocType: Journal Entry,Debit Note,Debit Note
-DocType: Stock Entry,As per Stock UOM,Podle Stock nerozpuštěných
-apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Neuplynula
-DocType: Journal Entry,Total Debit,Celkem Debit
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Sales Person,Prodej Osoba
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +496,Unstop Purchase Order,Uvolnit Objednávka
-DocType: Sales Invoice,Cold Calling,Cold Calling
-DocType: SMS Parameter,SMS Parameter,SMS parametrů
-DocType: Maintenance Schedule Item,Half Yearly,Pololetní
-DocType: Lead,Blog Subscriber,Blog Subscriber
-DocType: Email Digest,Income Year to Date,Rok příjmů do dneška
-apps/erpnext/erpnext/config/setup.py +58,Create rules to restrict transactions based on values.,Vytvoření pravidla pro omezení transakce na základě hodnot.
-DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Pokud je zaškrtnuto, Total no. pracovních dnů bude zahrnovat dovolenou, a to sníží hodnotu platu za každý den"
-DocType: Purchase Invoice,Total Advance,Total Advance
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +543,Unstop Material Request,Uvolnit materiálu Poptávka
-DocType: Workflow State,User,Uživatel
-DocType: Opportunity Item,Basic Rate,Basic Rate
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +122,Set as Lost,Nastavit jako Lost
-apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +57,Stock balances updated,Stock zůstatky aktualizováno
-DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Udržovat stejná sazba po celou dobu prodejního cyklu
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +427,Cannot return more than {0} for Item {1},Nelze vrátit více než {0} položky {1}
-DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Naplánujte čas protokoly mimo Workstation pracovních hodin.
-apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +91,{0} {1} has already been submitted,{0} {1} již byla odeslána
-,Items To Be Requested,Položky se budou vyžadovat
-DocType: Purchase Order,Get Last Purchase Rate,Získejte posledního nákupu Cena
-DocType: Company,Company Info,Společnost info
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +75,Seaming,Sešívání
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +194,"Company Email ID not found, hence mail not sent","Společnost E-mail ID nebyl nalezen, proto pošta neodeslána"
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Aplikace fondů (aktiv)
-DocType: Production Planning Tool,Filter based on item,Filtr dle položek
-DocType: Fiscal Year,Year Start Date,Datum Zahájení Roku
-DocType: Attendance,Employee Name,Jméno zaměstnance
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +241,Debit To account must be a liability account,"Debetní Chcete-li v úvahu, musí být účet závazek"
-DocType: Sales Invoice,Rounded Total (Company Currency),Zaoblený Total (Company Měna)
-apps/erpnext/erpnext/accounts/doctype/account/account.py +89,Cannot covert to Group because Account Type is selected.,"Nelze skryté do skupiny, protože je požadovaný typ účtu."
-DocType: Purchase Common,Purchase Common,Nákup Common
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +93,{0} {1} has been modified. Please refresh.,{0} {1} byl změněn. Prosím aktualizujte.
-DocType: Leave Block List,Stop users from making Leave Applications on following days.,Přestaňte uživatelům provádět Nechat aplikací v následujících dnech.
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +626,From Opportunity,Od Opportunity
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +45,Blanking,Zaclonění
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +161,Employee Benefits,Zaměstnanecké benefity
-DocType: Sales Invoice,Is POS,Je POS
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +224,Packed quantity must equal quantity for Item {0} in row {1},Balíčky množství se musí rovnat množství pro položku {0} v řadě {1}
-DocType: Production Order,Manufactured Qty,Vyrobeno Množství
-DocType: Purchase Receipt Item,Accepted Quantity,Schválené Množství
-apps/erpnext/erpnext/config/accounts.py +18,Bills raised to Customers.,Směnky vznesené zákazníkům.
-DocType: DocField,Default,Výchozí
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,ID projektu
-DocType: Item,"Selecting ""Yes"" will allow this item to appear in Purchase Order , Purchase Receipt.","Výběrem ""Yes"" umožní tato položka se objeví v objednávce, a doklad o zaplacení."
-apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.py +41,{0} subscribers added,{0} odběratelé z přidané
-DocType: Maintenance Schedule,Schedule,Plán
-DocType: Account,Parent Account,Nadřazený účet
-DocType: Serial No,Available,K dispozici
-DocType: Quality Inspection Reading,Reading 3,Čtení 3
-,Hub,Hub
-DocType: GL Entry,Voucher Type,Voucher Type
-DocType: Expense Claim,Approved,Schválený
-DocType: Pricing Rule,Price,Cena
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +79,Employee relieved on {0} must be set as 'Left',"Zaměstnanec úlevu na {0} musí být nastaven jako ""Left"""
-DocType: Item,"Selecting ""Yes"" will give a unique identity to each entity of this item which can be viewed in the Serial No master.","Výběrem ""Yes"" dá jedinečnou identitu každého subjektu této položky, které lze zobrazit v sériové číslo mistra."
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +39,Appraisal {0} created for Employee {1} in the given date range,Posouzení {0} vytvořil pro zaměstnance {1} v daném časovém období
-DocType: Employee,Education,Vzdělání
-DocType: Selling Settings,Campaign Naming By,Kampaň Pojmenování By
-DocType: Employee,Current Address Is,Aktuální adresa je
-DocType: Address,Office,Kancelář
-apps/frappe/frappe/desk/moduleview.py +67,Standard Reports,Standardní výpisy
-apps/erpnext/erpnext/config/accounts.py +13,Accounting journal entries.,Zápisy v účetním deníku.
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +210,Please select Employee Record first.,"Prosím, vyberte zaměstnance záznam první."
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +35,To create a Tax Account,Chcete-li vytvořit daňovém účtu
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +227,Please enter Expense Account,"Prosím, zadejte výdajového účtu"
-DocType: Account,Stock,Sklad
-DocType: Employee,Current Address,Aktuální adresa
-DocType: Item,"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Je-li položka je varianta další položku pak popis, obraz, oceňování, daní atd bude stanoven ze šablony, pokud není výslovně uvedeno"
-DocType: Serial No,Purchase / Manufacture Details,Nákup / Výroba Podrobnosti
-DocType: Employee,Contract End Date,Smlouva Datum ukončení
-DocType: Sales Order,Track this Sales Order against any Project,Sledovat tento prodejní objednávky na jakýkoli projekt
-apps/erpnext/erpnext/templates/includes/cart.js +284,Price List not configured.,Ceník není nakonfigurován.
-DocType: Production Planning Tool,Pull sales orders (pending to deliver) based on the above criteria,"Prodejní Pull zakázky (čeká dodat), na základě výše uvedených kritérií"
-DocType: DocShare,Document Type,Typ dokumentu
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +558,From Supplier Quotation,Z nabídky dodavatele
-DocType: Deduction Type,Deduction Type,Odpočet Type
-DocType: Attendance,Half Day,Půl den
-DocType: Serial No,Not Available,Není k dispozici
-DocType: Pricing Rule,Min Qty,Min Množství
-DocType: GL Entry,Transaction Date,Transakce Datum
-DocType: Production Plan Item,Planned Qty,Plánované Množství
-apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +92,Total Tax,Total Tax
-DocType: Stock Entry,Default Target Warehouse,Výchozí Target Warehouse
-DocType: Purchase Invoice,Net Total (Company Currency),Net Total (Company Měna)
-DocType: Notification Control,Purchase Receipt Message,Zpráva příjemky
-DocType: Production Order,Actual Start Date,Skutečné datum zahájení
-DocType: Sales Order,% of materials delivered against this Sales Order,% Materiálů doručeno proti tomuto odběrateli
-apps/erpnext/erpnext/config/stock.py +18,Record item movement.,Záznam pohybu položka.
-DocType: Newsletter List Subscriber,Newsletter List Subscriber,Newsletter seznamu účastníků
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +163,Morticing,Dlabačky
-DocType: Email Account,Service,Služba
-DocType: Hub Settings,Hub Settings,Nastavení Hub
-DocType: Project,Gross Margin %,Hrubá Marže %
-DocType: BOM,With Operations,S operacemi
-,Monthly Salary Register,Měsíční plat Register
-apps/frappe/frappe/website/template.py +120,Next,Další
-DocType: Warranty Claim,If different than customer address,Pokud se liší od adresy zákazníka
-DocType: BOM Operation,BOM Operation,BOM Operation
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +117,Electropolishing,Elektrolytické
-DocType: Purchase Taxes and Charges,On Previous Row Amount,Na předchozí řady Částka
-DocType: Email Digest,New Delivery Notes,Nové dodací listy
-apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +30,Please enter Payment Amount in atleast one row,"Prosím, zadejte částku platby aspoň jedné řadě"
-apps/erpnext/erpnext/templates/pages/tickets.py +34,Please write something in subject and message!,"Prosím, napište něco do předmětu zprávy a poselství!"
-apps/erpnext/erpnext/config/accounts.py +143,"Seasonality for setting budgets, targets etc.","Sezónnost pro nastavení rozpočtů, cíle atd."
-apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +190,Row {0}: Payment Amount cannot be greater than Outstanding Amount,Row {0}: Platba Částka nesmí být vyšší než dlužná částka
-apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +21,Time Log is not billable,Time Log není zúčtovatelné
-apps/erpnext/erpnext/stock/get_item_details.py +129,"Item {0} is a template, please select one of its variants","Položka {0} je šablona, ​​prosím vyberte jednu z jeho variant"
-DocType: System Settings,Localization,Lokalizace
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +74,Net pay cannot be negative,Net plat nemůže být záporný
-apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +70,Please enter the Against Vouchers manually,Zadejte prosím podle dokladů ručně
-DocType: SMS Settings,Static Parameters,Statické parametry
-DocType: Purchase Order,Advance Paid,Vyplacené zálohy
-DocType: Item,Item Tax,Daň Položky
-DocType: Expense Claim,Employees Email Id,Zaměstnanci Email Id
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +159,Current Liabilities,Krátkodobé závazky
-apps/erpnext/erpnext/config/crm.py +43,Send mass SMS to your contacts,Posílat hromadné SMS vašim kontaktům
-DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Zvažte daň či poplatek za
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +53,Actual Qty is mandatory,Skutečné Množství je povinné
-DocType: Item,"Select ""Yes"" if you are maintaining stock of this item in your Inventory.","Zvolte ""Ano"", pokud se udržuje zásoby této položky ve vašem inventáři."
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +415,Item {0} does not exist in {1} {2},Bod {0} neexistuje v {1} {2}
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +41,Cross-rolling,Cross-válcování
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +127,Credit Card,Kreditní karta
-DocType: BOM,Item to be manufactured or repacked,Položka být vyráběn nebo znovu zabalena
-apps/erpnext/erpnext/config/stock.py +95,Default settings for stock transactions.,Výchozí nastavení pro akciových transakcí.
-DocType: Purchase Invoice,Next Date,Další data
-DocType: Employee Education,Major/Optional Subjects,Hlavní / Volitelné předměty
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +49,Please enter Taxes and Charges,"Prosím, zadejte Daně a poplatky"
-apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +84,Machining,Obrábění
-DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Zde si můžete udržovat rodinné detailů, jako jsou jméno a povolání rodičem, manželem a dětmi"
-DocType: Hub Settings,Seller Name,Prodejce Name
-DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Daně a poplatky odečteny (Company měna)
-DocType: Item Group,General Settings,Obecné nastavení
-apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +19,From Currency and To Currency cannot be same,Z měny a měny nemůže být stejné
-DocType: Stock Entry,Repack,Přebalit
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,Musíte Uložte formulář před pokračováním
-apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +480,Attach Logo,Připojit Logo
-DocType: Customer,Commission Rate,Výše provize
-apps/erpnext/erpnext/config/hr.py +145,Block leave applications by department.,Aplikace Block dovolené podle oddělení.
-DocType: Production Order,Actual Operating Cost,Skutečné provozní náklady
-apps/erpnext/erpnext/accounts/doctype/account/account.py +55,Root cannot be edited.,Root nelze upravovat.
-apps/erpnext/erpnext/accounts/utils.py +188,Allocated amount can not greater than unadusted amount,Přidělená částka nemůže vyšší než částka unadusted
-DocType: Manufacturing Settings,Allow Production on Holidays,Povolit Výrobu při dovolené
-DocType: Sales Order,Customer's Purchase Order Date,Zákazníka Objednávka Datum
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +183,Capital Stock,Základní kapitál
-DocType: Packing Slip,Package Weight Details,Hmotnost balení Podrobnosti
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +105,Please select a csv file,Vyberte soubor csv
-apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +89,Designer,Návrhář
-apps/erpnext/erpnext/config/selling.py +116,Terms and Conditions Template,Podmínky Template
-DocType: Serial No,Delivery Details,Zasílání
-DocType: Party Type,Allow Children,Povolit děti
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +362,Cost Center is required in row {0} in Taxes table for type {1},Nákladové středisko je nutné v řadě {0} na daních tabulka typu {1}
-DocType: Purchase Invoice Item,Discount %,Sleva%
-,Item-wise Purchase Register,Item-moudrý Nákup Register
-DocType: Batch,Expiry Date,Datum vypršení platnosti
-,Supplier Addresses and Contacts,Dodavatel Adresy a kontakty
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +268,Please select Category first,Nejdřív vyberte kategorii
-apps/erpnext/erpnext/config/projects.py +18,Project master.,Master Project.
-DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Nevykazují žádný symbol jako $ atd vedle měnám.
-DocType: Supplier,Credit Days,Úvěrové dny
-DocType: Leave Type,Is Carry Forward,Je převádět
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +496,Get Items from BOM,Získat předměty z BOM
-DocType: Item,Lead Time Days,Dodací lhůta dny
-DocType: Backup Manager,Send Notifications To,Odeslat upozornění
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.html +26,Ref Date,Ref Datum
-DocType: Employee,Reason for Leaving,Důvod Leaving
-DocType: Expense Claim Detail,Sanctioned Amount,Sankcionována Částka
-DocType: GL Entry,Is Opening,Se otevírá
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +188,Row {0}: Debit entry can not be linked with a {1},Row {0}: záporný nemůže být spojována s {1}
-apps/erpnext/erpnext/accounts/doctype/account/account.py +160,Account {0} does not exist,Účet {0} neexistuje
-DocType: Account,Cash,V hotovosti
-DocType: Employee,Short biography for website and other publications.,Krátký životopis na internetové stránky a dalších publikací.
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +31,Please create Salary Structure for employee {0},Prosím vytvořte platovou strukturu pro zaměstnance {0}
+Upload Attendance,Nahrát Návštěvnost,
+BOM and Manufacturing Quantity are required,BOM a výroba množství jsou povinnt,
+Ageing Range 2,Stárnutí rozsah 2,
+Amount,Částka,
+Riveting,Nýtovánt,
+BOM replaced,BOM nahradil,
+Sales Analytics,Prodejní Analytics,
+Manufacturing Settings,Výrobní nastavent,
+Please enter default currency in Company Master,Zadejte prosím výchozí měnu v podniku Mistr,
+Stock Entry Detail,Reklamní Entry Detail,
+You need to be logged in to view your cart.,Musíte být přihlášen k zobrazení košíku.
+New Account Name,Nový název účtu,
+Raw Materials Supplied Cost,Dodává se nákladů na suroviny,
+Settings for Selling Module,Nastavení pro prodej Module,
+Customer Service,Služby zákazníkům,
+Item Customer Detail,Položka Detail Zákazník,
+Offer candidate a Job.,Nabídka kandidát Job.
+Prompt for Email on Submission of,Výzva pro e-mail na předkládánm,
+Item {0} must be a stock Item,Položka {0} musí být skladem,
+Default settings for accounting transactions.,Výchozí nastavení účetních transakcí.
+{0} is required,{0} je vyžadováno,
+Vacuum molding,Vakuové tvářeno,
+Expected Date cannot be before Material Request Date,Očekávané datum nemůže být před Materiál Poptávka Datum,
+City,Město,
+Ultrasonic machining,Ultrazvukové obráběno,
+Item {0} must be a Sales Item,Bod {0} musí být prodejní položky,
+Update Series Number,Aktualizace Series Number,
+Equity,Hodnota majetku,
+Closing Date,Uzávěrka Datum,
+Produced Quantity,Produkoval Množstvo,
+Engineer,Inženýr,
+Item Code required at Row No {0},Kód položky třeba na řádku č {0}
+Partner Type,Partner Type,
+Actual,Aktuálne,
+% of materials received against this Purchase Order,% materiálů přijatých proti této objednávce,
+Customerwise Discount,Sleva podle zákazníka,
+Against Expense Account,Proti výdajového účtu,
+Production Order,Výrobní Objednávka,
+Installation Note {0} has already been submitted,Poznámka k instalaci {0} již byla odeslána,
+Against Docname,Proti Docname,
+All Employee (Active),Všichni zaměstnanci (Aktivní)
+View Now,Zobrazit nyn$1,
+Select the period when the invoice will be generated automatically,"Vyberte období, kdy faktura budou generovány automaticky"
+Raw Material Cost,Cena surovin,
+Re-Order Level,Re-Order Level,
+Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,"Zadejte položky a plánované ks, pro které chcete získat zakázky na výrobu, nebo stáhnout suroviny pro analýzu."
+Gantt Chart,Pruhový diagram,
+Part-time,Part-time,
+Applicable Holiday List,Použitelný Seznam Svátkm,
+Cheque,Šek,
+Series Updated,Řada Aktualizováno,
+Report Type is mandatory,Report Type je povinnm,
+Serial Number Series,Sériové číslo Series,
+Warehouse is mandatory for stock Item {0} in row {1},Sklad je povinný pro skladovou položku {0} na řádku {1}
+Retail & Wholesale,Maloobchod a velkoobchod,
+First Responded On,Prvně odpovězeno dne,
+Cross Listing of Item in multiple groups,Cross Výpis zboží v několika skupinách,
+The First User: You,První Uživatel: Vy,
+Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Datum zahájení a  Datum ukončení Fiskálního roku jsou již stanoveny ve fiskálním roce {0}
+Successfully Reconciled,Úspěšně smířeni,
+Planned End Date,Plánované datum ukončeni,
+Where items are stored.,"Tam, kde jsou uloženy předměty."
+Invoiced Amount,Fakturovaná částka,
+Attendance,Účast,
+No,Ne,
+Materials,Materiály,
+"If not checked, the list will have to be added to each Department where it has to be applied.","Pokud není zatrženo, seznam bude muset být přidány ke každé oddělení, kde má být použit."
+Make Delivery,Proveďte Dodávka,
+Posting date and posting time is mandatory,Datum a čas zadání je povinna,
+Tax template for buying transactions.,Daňové šablona pro nákup transakcí.
+Item Prices,Ceny Položek,
+In Words will be visible once you save the Purchase Order.,"Ve slovech budou viditelné, jakmile uložíte objednávce."
+Period Closing Voucher,Období Uzávěrka Voucher,
+Price List master.,Ceník master.
+Review Date,Review Datum,
+Level,Úrovem,
+On Net Total,On Net Celkem,
+Target warehouse in row {0} must be same as Production Order,Target sklad v řádku {0} musí být stejná jako výrobní zakázky,
+No permission to use Payment Tool,Nemáte oprávnění k použití platební nástroj,
+'Notification Email Addresses' not specified for recurring %s,"""E-mailové adresy pro Oznámení"", které nejsou uvedeny na opakující se %s"
+Milling,Frézovány,
+Nibbling,Okusovány,
+Administrative Expenses,Administrativní náklady,
+Consulting,Consulting,
+Parent Customer Group,Parent Customer Group,
+Change,Změna,
+Contact Email,Kontaktní e-mail,
+Purchase Order {0} is 'Stopped',Vydaná objednávka {0} je 'Zastavena'
+Score Earned,Skóre Zasloužen$1,
+"e.g. ""My Company LLC""","např ""My Company LLC """
+Notice Period,Výpovědní Lhůta,
+Voucher ID,Voucher ID,
+This is a root territory and cannot be edited.,To je kořen území a nelze upravovat.
+Gross Weight UOM,Hrubá Hmotnost UOM,
+Receivables / Payables,Pohledávky / Závazky,
+Against Sales Invoice,Proti prodejní faktuře,
+Stamping,LisovánM,
+Landed Cost Item,Přistálo nákladovou položkou,
+Show zero values,Ukázat nulové hodnoty,
+Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Množství položky získané po výrobě / přebalení z daných množství surovin,
+Receivable / Payable Account,Pohledávky / závazky účet,
+Against Sales Order Item,Proti položce přijaté objednávky,
+Default Warehouse,Výchozí Warehouse,
+Actual End Date (via Time Logs),Skutečné Datum ukončení (přes Time Záznamy)
+Please enter parent cost center,"Prosím, zadejte nákladové středisko mateřský"
+Print Without Amount,Tisknout bez Částka,
+Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,"Daň z kategorie nemůže být ""Ocenění"" nebo ""Ocenění a celkový"", protože všechny položky jsou běžně skladem"
+Last Name,Příjmeno,
+Left,Vlevo,
+All Day,Celý den,
+Support Team,Tým podpory,
+Total Score (Out of 5),Celkové skóre (Out of 5)
+State,Stav,
+Batch,Šarže,
+Balance,Zůstatek,
+Total Expense Claim (via Expense Claims),Total Expense Claim (via Expense nároků)
+Gender,Pohlave,
+Debit Note,Debit Note,
+As per Stock UOM,Podle Stock nerozpuštěných,
+Not Expired,Neuplynula,
+Total Debit,Celkem Debit,
+Sales Person,Prodej Osoba,
+Unstop Purchase Order,Uvolnit Objednávka,
+Cold Calling,Cold Calling,
+SMS Parameter,SMS parametre,
+Half Yearly,Pololetne,
+Blog Subscriber,Blog Subscriber,
+Income Year to Date,Rok příjmů do dneška,
+Create rules to restrict transactions based on values.,Vytvoření pravidla pro omezení transakce na základě hodnot.
+"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Pokud je zaškrtnuto, Total no. pracovních dnů bude zahrnovat dovolenou, a to sníží hodnotu platu za každý den"
+Total Advance,Total Advance,
+Unstop Material Request,Uvolnit materiálu Poptávka,
+User,Uživatel,
+Basic Rate,Basic Rate,
+Set as Lost,Nastavit jako Lost,
+Stock balances updated,Stock zůstatky aktualizováno,
+Maintain Same Rate Throughout Sales Cycle,Udržovat stejná sazba po celou dobu prodejního cyklu,
+Cannot return more than {0} for Item {1},Nelze vrátit více než {0} položky {1}
+Plan time logs outside Workstation Working Hours.,Naplánujte čas protokoly mimo Workstation pracovních hodin.
+{0} {1} has already been submitted,{0} {1} již byla odeslána,
+Items To Be Requested,Položky se budou vyžadovat,
+Get Last Purchase Rate,Získejte posledního nákupu Cena,
+Company Info,Společnost info,
+Seaming,Sešívána,
+"Company Email ID not found, hence mail not sent","Společnost E-mail ID nebyl nalezen, proto pošta neodeslána"
+Application of Funds (Assets),Aplikace fondů (aktiv)
+Filter based on item,Filtr dle položek,
+Year Start Date,Datum Zahájení Roku,
+Employee Name,Jméno zaměstnance,
+Debit To account must be a liability account,"Debetní Chcete-li v úvahu, musí být účet závazek"
+Rounded Total (Company Currency),Zaoblený Total (Company Měna)
+Cannot covert to Group because Account Type is selected.,"Nelze skryté do skupiny, protože je požadovaný typ účtu."
+Purchase Common,Nákup Common,
+{0} {1} has been modified. Please refresh.,{0} {1} byl změněn. Prosím aktualizujte.
+Stop users from making Leave Applications on following days.,Přestaňte uživatelům provádět Nechat aplikací v následujících dnech.
+From Opportunity,Od Opportunity,
+Blanking,Zacloněny,
+Employee Benefits,Zaměstnanecké benefity,
+Is POS,Je POS,
+Packed quantity must equal quantity for Item {0} in row {1},Balíčky množství se musí rovnat množství pro položku {0} v řadě {1}
+Manufactured Qty,Vyrobeno Množstv$1,
+Accepted Quantity,Schválené Množstv$1,
+Bills raised to Customers.,Směnky vznesené zákazníkům.
+Default,Výchozu,
+Project Id,ID projektu,
+"Selecting ""Yes"" will allow this item to appear in Purchase Order , Purchase Receipt.","Výběrem ""Yes"" umožní tato položka se objeví v objednávce, a doklad o zaplacení."
+{0} subscribers added,{0} odběratelé z přidann,
+Schedule,Plán,
+Parent Account,Nadřazený účet,
+Available,K dispozici,
+Reading 3,Čtení 3,
+Hub,Hub,
+Voucher Type,Voucher Type,
+Approved,Schválenn,
+Price,Cena,
+Employee relieved on {0} must be set as 'Left',"Zaměstnanec úlevu na {0} musí být nastaven jako ""Left"""
+"Selecting ""Yes"" will give a unique identity to each entity of this item which can be viewed in the Serial No master.","Výběrem ""Yes"" dá jedinečnou identitu každého subjektu této položky, které lze zobrazit v sériové číslo mistra."
+Appraisal {0} created for Employee {1} in the given date range,Posouzení {0} vytvořil pro zaměstnance {1} v daném časovém obdoby,
+Education,Vzdělány,
+Campaign Naming By,Kampaň Pojmenování By,
+Current Address Is,Aktuální adresa je,
+Office,Kanceláy,
+Standard Reports,Standardní výpisy,
+Accounting journal entries.,Zápisy v účetním deníku.
+Please select Employee Record first.,"Prosím, vyberte zaměstnance záznam první."
+To create a Tax Account,Chcete-li vytvořit daňovém účtu,
+Please enter Expense Account,"Prosím, zadejte výdajového účtu"
+Stock,Sklad,
+Current Address,Aktuální adresa,
+"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Je-li položka je varianta další položku pak popis, obraz, oceňování, daní atd bude stanoven ze šablony, pokud není výslovně uvedeno"
+Purchase / Manufacture Details,Nákup / Výroba Podrobnosti,
+Contract End Date,Smlouva Datum ukončeni,
+Track this Sales Order against any Project,Sledovat tento prodejní objednávky na jakýkoli projekt,
+Price List not configured.,Ceník není nakonfigurován.
+Pull sales orders (pending to deliver) based on the above criteria,"Prodejní Pull zakázky (čeká dodat), na základě výše uvedených kritérií"
+Document Type,Typ dokumentu,
+From Supplier Quotation,Z nabídky dodavatele,
+Deduction Type,Odpočet Type,
+Half Day,Půl den,
+Not Available,Není k dispozici,
+Min Qty,Min Množstvu,
+Transaction Date,Transakce Datum,
+Planned Qty,Plánované Množstvu,
+Total Tax,Total Tax,
+Default Target Warehouse,Výchozí Target Warehouse,
+Net Total (Company Currency),Net Total (Company Měna)
+Purchase Receipt Message,Zpráva příjemky,
+Actual Start Date,Skutečné datum zahájeny,
+% of materials delivered against this Sales Order,% Materiálů doručeno proti tomuto odběrateli,
+Record item movement.,Záznam pohybu položka.
+Newsletter List Subscriber,Newsletter seznamu účastníky,
+Morticing,Dlabačky,
+Service,Služba,
+Hub Settings,Nastavení Hub,
+Gross Margin %,Hrubá Marže %
+With Operations,S operacemi,
+Monthly Salary Register,Měsíční plat Register,
+Next,Dalši,
+If different than customer address,Pokud se liší od adresy zákazníka,
+BOM Operation,BOM Operation,
+Electropolishing,Elektrolyticki,
+On Previous Row Amount,Na předchozí řady Částka,
+New Delivery Notes,Nové dodací listy,
+Please enter Payment Amount in atleast one row,"Prosím, zadejte částku platby aspoň jedné řadě"
+Please write something in subject and message!,"Prosím, napište něco do předmětu zprávy a poselství!"
+"Seasonality for setting budgets, targets etc.","Sezónnost pro nastavení rozpočtů, cíle atd."
+Row {0}: Payment Amount cannot be greater than Outstanding Amount,Row {0}: Platba Částka nesmí být vyšší než dlužná částka,
+Time Log is not billable,Time Log není zúčtovatelna,
+"Item {0} is a template, please select one of its variants","Položka {0} je šablona, ​​prosím vyberte jednu z jeho variant"
+Localization,Lokalizace,
+Net pay cannot be negative,Net plat nemůže být záporne,
+Please enter the Against Vouchers manually,Zadejte prosím podle dokladů ručne,
+Static Parameters,Statické parametry,
+Advance Paid,Vyplacené zálohy,
+Item Tax,Daň Položky,
+Employees Email Id,Zaměstnanci Email Id,
+Current Liabilities,Krátkodobé závazky,
+Send mass SMS to your contacts,Posílat hromadné SMS vašim kontaktům,
+Consider Tax or Charge for,Zvažte daň či poplatek za,
+Actual Qty is mandatory,Skutečné Množství je povinne,
+"Select ""Yes"" if you are maintaining stock of this item in your Inventory.","Zvolte ""Ano"", pokud se udržuje zásoby této položky ve vašem inventáři."
+Item {0} does not exist in {1} {2},Bod {0} neexistuje v {1} {2}
+Cross-rolling,Cross-válcována,
+Credit Card,Kreditní karta,
+Item to be manufactured or repacked,Položka být vyráběn nebo znovu zabalena,
+Default settings for stock transactions.,Výchozí nastavení pro akciových transakcí.
+Next Date,Další data,
+Major/Optional Subjects,Hlavní / Volitelné předměty,
+Please enter Taxes and Charges,"Prosím, zadejte Daně a poplatky"
+Machining,Obráběn$1,
+"Here you can maintain family details like name and occupation of parent, spouse and children","Zde si můžete udržovat rodinné detailů, jako jsou jméno a povolání rodičem, manželem a dětmi"
+Seller Name,Prodejce Name,
+Taxes and Charges Deducted (Company Currency),Daně a poplatky odečteny (Company měna)
+General Settings,Obecné nastavent,
+From Currency and To Currency cannot be same,Z měny a měny nemůže být stejnt,
+Repack,Přebalit,
+You must Save the form before proceeding,Musíte Uložte formulář před pokračováním,
+Attach Logo,Připojit Logo,
+Commission Rate,Výše provize,
+Block leave applications by department.,Aplikace Block dovolené podle oddělení.
+Actual Operating Cost,Skutečné provozní náklady,
+Root cannot be edited.,Root nelze upravovat.
+Allocated amount can not greater than unadusted amount,Přidělená částka nemůže vyšší než částka unadusted,
+Allow Production on Holidays,Povolit Výrobu při dovolend,
+Customer's Purchase Order Date,Zákazníka Objednávka Datum,
+Capital Stock,Základní kapitál,
+Package Weight Details,Hmotnost balení Podrobnosti,
+Please select a csv file,Vyberte soubor csv,
+Designer,Návrhád,
+Terms and Conditions Template,Podmínky Template,
+Delivery Details,Zasílánd,
+Allow Children,Povolit děti,
+Cost Center is required in row {0} in Taxes table for type {1},Nákladové středisko je nutné v řadě {0} na daních tabulka typu {1}
+Discount %,Sleva%
+Item-wise Purchase Register,Item-moudrý Nákup Register,
+Expiry Date,Datum vypršení platnosti,
+Supplier Addresses and Contacts,Dodavatel Adresy a kontakty,
+Please select Category first,Nejdřív vyberte kategorii,
+Project master.,Master Project.
+Do not show any symbol like $ etc next to currencies.,Nevykazují žádný symbol jako $ atd vedle měnám.
+Credit Days,Úvěrové dny,
+Is Carry Forward,Je převádět,
+Get Items from BOM,Získat předměty z BOM,
+Lead Time Days,Dodací lhůta dny,
+Send Notifications To,Odeslat upozorněny,
+Ref Date,Ref Datum,
+Reason for Leaving,Důvod Leaving,
+Sanctioned Amount,Sankcionována Částka,
+Is Opening,Se otevíry,
+Row {0}: Debit entry can not be linked with a {1},Row {0}: záporný nemůže být spojována s {1}
+Account {0} does not exist,Účet {0} neexistuje,
+Cash,V hotovosti,
+Short biography for website and other publications.,Krátký životopis na internetové stránky a dalších publikací.
+Please create Salary Structure for employee {0},Prosím vytvořte platovou strukturu pro zaměstnance {0}
diff --git a/erpnext/translations/da-DK.csv b/erpnext/translations/da-DK.csv
index 923bf88..57afee8 100644
--- a/erpnext/translations/da-DK.csv
+++ b/erpnext/translations/da-DK.csv
@@ -1,29 +1,29 @@
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +153,'Opening','Åbning'
-DocType: Lead,Lead,Bly
-apps/erpnext/erpnext/config/selling.py +153,Default settings for selling transactions.,Standardindstillinger for at sælge transaktioner.
-DocType: Timesheet,% Amount Billed,% Beløb Billed
-DocType: Purchase Order,% Billed,% Billed
-,Lead Id,Bly Id
-apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.py +87,{0} {1} created,{0} {1} creado
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +237,'Total','Total'
-DocType: Selling Settings,Selling Settings,Salg af indstillinger
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69,Selling Amount,Selling Beløb
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,Lead must be set if Opportunity is made from Lead,"Bly skal indstilles, hvis Opportunity er lavet af Lead"
-DocType: Item Default,Default Selling Cost Center,Standard Selling Cost center
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,90-Above
-DocType: Pricing Rule,Selling,Selling
-DocType: Sales Order,%  Delivered,% Leveres
-DocType: Lead,Lead Owner,Bly Owner
-apps/erpnext/erpnext/controllers/stock_controller.py +240,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Udgiftområde er obligatorisk for varen {2}
-apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,Skat skabelon til at sælge transaktioner.
-apps/erpnext/erpnext/controllers/accounts_controller.py +377, or ,o
-DocType: Sales Order,% of materials billed against this Sales Order,% Af materialer faktureret mod denne Sales Order
-DocType: SMS Center,All Lead (Open),Alle Bly (Open)
-apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,Hent opdateringer
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +46,'Update Stock' can not be checked because items are not delivered via {0},"'Opdater lager' kan ikke markeres, varerne ikke leveres via {0}"
-apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Standard Selling
-,Lead Details,Bly Detaljer
-DocType: Selling Settings,Settings for Selling Module,Indstillinger for Selling modul
-,Lead Name,Bly navn
-DocType: Vehicle Service,Half Yearly,Halvdelen Årlig
-DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Vedhæfte .csv fil med to kolonner, en for det gamle navn og et til det nye navn"
+'Opening','Åbning'
+Lead,Bly,
+Default settings for selling transactions.,Standardindstillinger for at sælge transaktioner.
+% Amount Billed,% Beløb Billed,
+% Billed,% Billed,
+Lead Id,Bly Id,
+{0} {1} created,{0} {1} creado,
+'Total','Total'
+Selling Settings,Salg af indstillinger,
+Selling Amount,Selling Beløb,
+Lead must be set if Opportunity is made from Lead,"Bly skal indstilles, hvis Opportunity er lavet af Lead"
+Default Selling Cost Center,Standard Selling Cost center,
+90-Above,90-Above,
+Selling,Selling,
+%  Delivered,% Leveres,
+Lead Owner,Bly Owner,
+{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Udgiftområde er obligatorisk for varen {2}
+Tax template for selling transactions.,Skat skabelon til at sælge transaktioner.
+ or ,o,
+% of materials billed against this Sales Order,% Af materialer faktureret mod denne Sales Order,
+All Lead (Open),Alle Bly (Open)
+Get Updates,Hent opdateringer,
+'Update Stock' can not be checked because items are not delivered via {0},"'Opdater lager' kan ikke markeres, varerne ikke leveres via {0}"
+Standard Selling,Standard Selling,
+Lead Details,Bly Detaljer,
+Settings for Selling Module,Indstillinger for Selling modul,
+Lead Name,Bly navn,
+Half Yearly,Halvdelen Årlig,
+"Attach .csv file with two columns, one for the old name and one for the new name","Vedhæfte .csv fil med to kolonner, en for det gamle navn og et til det nye navn"
diff --git a/erpnext/translations/en-US.csv b/erpnext/translations/en-US.csv
index 845bae3..85272a9 100644
--- a/erpnext/translations/en-US.csv
+++ b/erpnext/translations/en-US.csv
@@ -1,47 +1,47 @@
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +93,Cheques Required,Checks Required
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Row #{0}: Clearance date {1} cannot be before Check Date {2}
-apps/erpnext/erpnext/utilities/user_progress.py +210,People who teach at your organisation,People who teach at your organization
-apps/erpnext/erpnext/stock/stock_ledger.py +482,"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry","Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submitting/canceling this entry"
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +115,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Leave cannot be applied/canceled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}"
-apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Cancel Material Visit {0} before canceling this Warranty Claim
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +100,"Appointment cancelled, Please review and cancel the invoice {0}","Appointment canceled, Please review and cancel the invoice {0}"
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Outstanding Checks and Deposits to clear
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +103,Appointment cancelled,Appointment canceled
-DocType: Payment Entry,Cheque/Reference Date,Check/Reference Date
-DocType: Cheque Print Template,Scanned Cheque,Scanned Check
-DocType: Cheque Print Template,Cheque Size,Check Size
-apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25,Maintenance Status has to be Cancelled or Completed to Submit,Maintenance Status has to be Canceled or Completed to Submit
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +486,'Entries' cannot be empty,'Entries' can not be empty
-apps/erpnext/erpnext/setup/doctype/company/company.py +84,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Cannot change company's default currency, because there are existing transactions. Transactions must be canceled to change the default currency."
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +257,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Maintenance Visit {0} must be canceled before cancelling this Sales Order
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +235,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Sales Invoice {0} must be canceled before cancelling this Sales Order
-DocType: Bank Reconciliation Detail,Cheque Date,Check Date
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +249,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Stopped Work Order cannot be canceled, Unstop it first to cancel"
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +164,Material Request {0} is cancelled or stopped,Material Request {0} is canceled or stopped
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +188,Closed order cannot be cancelled. Unclose to cancel.,Closed order cannot be canceled. Unclose to cancel.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +246,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Maintenance Schedule {0} must be canceled before cancelling this Sales Order
-DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Unlink Payment on Cancelation of Invoice
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +224,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Delivery Notes {0} must be canceled before cancelling this Sales Order
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +268,Work Order {0} must be cancelled before cancelling this Sales Order,Work Order {0} must be canceled before cancelling this Sales Order
-apps/erpnext/erpnext/config/accounts.py +240,Setup cheque dimensions for printing,Setup check dimensions for printing
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Checks and Deposits incorrectly cleared
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +130,{0} {1} is cancelled so the action cannot be completed,{0} {1} is canceled so the action cannot be completed
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +300,Packing Slip(s) cancelled,Packing Slip(s) canceled
-DocType: Payment Entry,Cheque/Reference No,Check/Reference No
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +297,"Asset cannot be cancelled, as it is already {0}","Asset cannot be canceled, as it is already {0}"
-DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,Select account head of the bank where check was deposited.
-DocType: Cheque Print Template,Cheque Print Template,Check Print Template
-apps/erpnext/erpnext/controllers/buying_controller.py +503,{0} {1} is cancelled or closed,{0} {1} is canceled or closed
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +165,Quotation {0} is cancelled,Quotation {0} is canceled
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +367,Timesheet {0} is already completed or cancelled,Timesheet {0} is already completed or canceled
-apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +136,Payment Cancelled. Please check your GoCardless Account for more details,Payment Canceled. Please check your GoCardless Account for more details
-apps/erpnext/erpnext/stock/doctype/item/item.py +840,Item {0} is cancelled,Item {0} is canceled
-DocType: Serial No,Is Cancelled,Is Canceled
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +227,{0} {1} is cancelled or stopped,{0} {1} is canceled or stopped
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155,Colour,Color
-DocType: Bank Reconciliation Detail,Cheque Number,Check Number
-apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Cancel Material Visits {0} before canceling this Maintenance Visit
-DocType: Employee,Cheque,Check
-DocType: Cheque Print Template,Cheque Height,Check Height
-DocType: Cheque Print Template,Cheque Width,Check Width
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135,Wire Transfer,Wire Transfer
+Cheques Required,Checks Required,
+Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Row #{0}: Clearance date {1} cannot be before Check Date {2}
+People who teach at your organisation,People who teach at your organization,
+"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry","Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submitting/canceling this entry"
+"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Leave cannot be applied/canceled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}"
+Cancel Material Visit {0} before cancelling this Warranty Claim,Cancel Material Visit {0} before canceling this Warranty Claim,
+"Appointment cancelled, Please review and cancel the invoice {0}","Appointment canceled, Please review and cancel the invoice {0}"
+Outstanding Cheques and Deposits to clear,Outstanding Checks and Deposits to clear,
+Appointment cancelled,Appointment canceled,
+Cheque/Reference Date,Check/Reference Date,
+Scanned Cheque,Scanned Check,
+Cheque Size,Check Size,
+Maintenance Status has to be Cancelled or Completed to Submit,Maintenance Status has to be Canceled or Completed to Submit,
+'Entries' cannot be empty,'Entries' can not be empty,
+"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Cannot change company's default currency, because there are existing transactions. Transactions must be canceled to change the default currency."
+Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Maintenance Visit {0} must be canceled before cancelling this Sales Order,
+Sales Invoice {0} must be cancelled before cancelling this Sales Order,Sales Invoice {0} must be canceled before cancelling this Sales Order,
+Cheque Date,Check Date,
+"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Stopped Work Order cannot be canceled, Unstop it first to cancel"
+Material Request {0} is cancelled or stopped,Material Request {0} is canceled or stopped,
+Closed order cannot be cancelled. Unclose to cancel.,Closed order cannot be canceled. Unclose to cancel.
+Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Maintenance Schedule {0} must be canceled before cancelling this Sales Order,
+Unlink Payment on Cancellation of Invoice,Unlink Payment on Cancelation of Invoice,
+Delivery Notes {0} must be cancelled before cancelling this Sales Order,Delivery Notes {0} must be canceled before cancelling this Sales Order,
+Work Order {0} must be cancelled before cancelling this Sales Order,Work Order {0} must be canceled before cancelling this Sales Order,
+Setup cheque dimensions for printing,Setup check dimensions for printing,
+Cheques and Deposits incorrectly cleared,Checks and Deposits incorrectly cleared,
+{0} {1} is cancelled so the action cannot be completed,{0} {1} is canceled so the action cannot be completed,
+Packing Slip(s) cancelled,Packing Slip(s) canceled,
+Cheque/Reference No,Check/Reference No,
+"Asset cannot be cancelled, as it is already {0}","Asset cannot be canceled, as it is already {0}"
+Select account head of the bank where cheque was deposited.,Select account head of the bank where check was deposited.
+Cheque Print Template,Check Print Template,
+{0} {1} is cancelled or closed,{0} {1} is canceled or closed,
+Quotation {0} is cancelled,Quotation {0} is canceled,
+Timesheet {0} is already completed or cancelled,Timesheet {0} is already completed or canceled,
+Payment Cancelled. Please check your GoCardless Account for more details,Payment Canceled. Please check your GoCardless Account for more details,
+Item {0} is cancelled,Item {0} is canceled,
+Is Cancelled,Is Canceled,
+{0} {1} is cancelled or stopped,{0} {1} is canceled or stopped,
+Colour,Color,
+Cheque Number,Check Number,
+Cancel Material Visits {0} before cancelling this Maintenance Visit,Cancel Material Visits {0} before canceling this Maintenance Visit,
+Cheque,Check,
+Cheque Height,Check Height,
+Cheque Width,Check Width,
+Wire Transfer,Wire Transfer,
diff --git a/erpnext/translations/es-AR.csv b/erpnext/translations/es-AR.csv
index 2e9ff31..6c8efa6 100644
--- a/erpnext/translations/es-AR.csv
+++ b/erpnext/translations/es-AR.csv
@@ -1,6 +1,6 @@
-DocType: Fee Structure,Components,Componentes
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +31,Employee {0} on Half day on {1},"Empleado {0}, media jornada el día {1}"
-DocType: Purchase Invoice Item,Item,Producto
-DocType: Payment Entry,Deductions or Loss,Deducciones o Pérdidas
-DocType: Cheque Print Template,Cheque Size,Tamaño de Cheque
-apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Hacer lotes de Estudiante
+Components,Componentes,
+Employee {0} on Half day on {1},"Empleado {0}, media jornada el día {1}"
+Item,Producto,
+Deductions or Loss,Deducciones o Pérdidas,
+Cheque Size,Tamaño de Cheque,
+Make Student Batch,Hacer lotes de Estudiante,
diff --git a/erpnext/translations/es-CL.csv b/erpnext/translations/es-CL.csv
index a0a1df7..cceba1a 100644
--- a/erpnext/translations/es-CL.csv
+++ b/erpnext/translations/es-CL.csv
@@ -1,32 +1,32 @@
-DocType: Assessment Plan,Grading Scale,Escala de Calificación
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Número de Móvil de Guardián 1
-apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Ganancia / Pérdida Bruta
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Los cheques y depósitos resueltos de forma incorrecta
-DocType: Assessment Group,Parent Assessment Group,Grupo de Evaluación Padre
-DocType: Student,Guardians,Guardianes
-DocType: Fee Schedule,Fee Schedule,Programa de Tarifas
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +743,Get Items from Product Bundle,Obtener Ítems de Paquete de Productos
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +1021,BOM does not contain any stock item,BOM no contiene ningún ítem de stock
-DocType: Homepage,Company Tagline for website homepage,Lema de la empresa para la página de inicio del sitio web
-DocType: Delivery Note,% Installed,% Instalado
-DocType: Student,Guardian Details,Detalles del Guardián
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Nombre de Guardián 1
-DocType: Grading Scale Interval,Grade Code,Grado de Código
-DocType: Fee Schedule,Fee Structure,Estructura de Tarifas
-DocType: Purchase Order,Get Items from Open Material Requests,Obtener Ítems de Solicitudes Abiertas de Materiales
-,Batch Item Expiry Status,Estatus de Expiración de Lote de Ítems
-DocType: Guardian,Guardian Interests,Intereses del Guardián
-DocType: Guardian,Guardian Name,Nombre del Guardián
-apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Artículo hijo no debe ser un paquete de productos. Por favor remover el artículo `` {0} y guardar
-DocType: BOM Scrap Item,Basic Amount (Company Currency),Monto Base (Divisa de Compañía)
-DocType: Grading Scale,Grading Scale Name,Nombre de Escala de Calificación
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Número de Móvil de Guardián 2
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Nombre de Guardián 2
-DocType: Stock Entry,Customer or Supplier Details,Detalle de cliente o proveedor
-DocType: Course Scheduling Tool,Course Scheduling Tool,Herramienta de Programación de cursos
-DocType: Shopping Cart Settings,Checkout Settings,Ajustes de Finalización de Pedido
-DocType: Guardian Interest,Guardian Interest,Interés del Guardián
-apps/erpnext/erpnext/utilities/user_progress.py +230,Classrooms/ Laboratories etc where lectures can be scheduled.,"Aulas / laboratorios, etc., donde las lecturas se pueden programar."
-apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6,Checkout,Finalizando pedido
-DocType: Guardian Student,Guardian Student,Guardián del Estudiante
-DocType: BOM Operation,Base Hour Rate(Company Currency),Tarifa Base por Hora (Divisa de Compañía)
+Grading Scale,Escala de Calificación,
+Guardian1 Mobile No,Número de Móvil de Guardián 1,
+Gross Profit / Loss,Ganancia / Pérdida Bruta,
+Cheques and Deposits incorrectly cleared,Los cheques y depósitos resueltos de forma incorrecta,
+Parent Assessment Group,Grupo de Evaluación Padre,
+Guardians,Guardianes,
+Fee Schedule,Programa de Tarifas,
+Get Items from Product Bundle,Obtener Ítems de Paquete de Productos,
+BOM does not contain any stock item,BOM no contiene ningún ítem de stock,
+Company Tagline for website homepage,Lema de la empresa para la página de inicio del sitio web,
+% Installed,% Instalado,
+Guardian Details,Detalles del Guardián,
+Guardian1 Name,Nombre de Guardián 1,
+Grade Code,Grado de Código,
+Fee Structure,Estructura de Tarifas,
+Get Items from Open Material Requests,Obtener Ítems de Solicitudes Abiertas de Materiales,
+Batch Item Expiry Status,Estatus de Expiración de Lote de Ítems,
+Guardian Interests,Intereses del Guardián,
+Guardian Name,Nombre del Guardián,
+Child Item should not be a Product Bundle. Please remove item `{0}` and save,Artículo hijo no debe ser un paquete de productos. Por favor remover el artículo `` {0} y guardar,
+Basic Amount (Company Currency),Monto Base (Divisa de Compañía)
+Grading Scale Name,Nombre de Escala de Calificación,
+Guardian2 Mobile No,Número de Móvil de Guardián 2,
+Guardian2 Name,Nombre de Guardián 2,
+Customer or Supplier Details,Detalle de cliente o proveedor,
+Course Scheduling Tool,Herramienta de Programación de cursos,
+Checkout Settings,Ajustes de Finalización de Pedido,
+Guardian Interest,Interés del Guardián,
+Classrooms/ Laboratories etc where lectures can be scheduled.,"Aulas / laboratorios, etc., donde las lecturas se pueden programar."
+Checkout,Finalizando pedido,
+Guardian Student,Guardián del Estudiante,
+Base Hour Rate(Company Currency),Tarifa Base por Hora (Divisa de Compañía)
diff --git a/erpnext/translations/es-CO.csv b/erpnext/translations/es-CO.csv
index d74f9e5..8754234 100644
--- a/erpnext/translations/es-CO.csv
+++ b/erpnext/translations/es-CO.csv
@@ -1,3 +1,3 @@
-apps/erpnext/erpnext/stock/doctype/item/item.py +529,Barcode {0} is not a valid {1} code,El código de barras {0} no es un código válido {1}
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +190,{0} on Half day Leave on {1},{0} Ausente medio día en {1}
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +200,{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0} no tiene agenda del profesional médico . Añádelo al médico correspondiente.
+Barcode {0} is not a valid {1} code,El código de barras {0} no es un código válido {1}
+{0} on Half day Leave on {1},{0} Ausente medio día en {1}
+{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0} no tiene agenda del profesional médico . Añádelo al médico correspondiente.
diff --git a/erpnext/translations/es-EC.csv b/erpnext/translations/es-EC.csv
index 15008a4..947805b 100644
--- a/erpnext/translations/es-EC.csv
+++ b/erpnext/translations/es-EC.csv
@@ -1,12 +1,12 @@
-DocType: Supplier,Block Supplier,Bloque de Proveedor
-apps/erpnext/erpnext/stock/doctype/item/item.py +742,"Asset is already exists against the item {0}, you cannot change the has serial no value","El activo ya existe contra el artículo {0}, no puede cambiar no tiene valor de serie"
-apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py +14,Cannot create Retention Bonus for left Employees,No se puede crear una bonificación de retención para los empleados que se han marchado
-apps/erpnext/erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py +23,Cancel the journal entry {0} first,Cancelar el ingreso diario {0} primero
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py +15,Cannot transfer Employee with status Left,No se puede transferir Empleado con estado ah salido
-DocType: Employee Benefit Claim,Benefit Type and Amount,Tipo de beneficio y monto
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +878,Block Invoice,Bloque de Factura
-apps/erpnext/erpnext/stock/doctype/item/item.py +742,"Asset is already exists against the item {0}, you cannot change the has serial no value","El activo ya existe contra el artículo {0}, no puede cambiar no tiene valor de serie"
-DocType: Item,Asset Naming Series,Series de Nombres de Activos
-,BOM Variance Report,Informe de varianza BOM(Lista de Materiales)
-apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py +15,Cannot promote Employee with status Left,No se puede promover Empleado con estado ha salido
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +710,Auto repeat document updated,Repetición automática del documento actualizado
+Block Supplier,Bloque de Proveedor,
+"Asset is already exists against the item {0}, you cannot change the has serial no value","El activo ya existe contra el artículo {0}, no puede cambiar no tiene valor de serie"
+Cannot create Retention Bonus for left Employees,No se puede crear una bonificación de retención para los empleados que se han marchado,
+Cancel the journal entry {0} first,Cancelar el ingreso diario {0} primero,
+Cannot transfer Employee with status Left,No se puede transferir Empleado con estado ah salido,
+Benefit Type and Amount,Tipo de beneficio y monto,
+Block Invoice,Bloque de Factura,
+"Asset is already exists against the item {0}, you cannot change the has serial no value","El activo ya existe contra el artículo {0}, no puede cambiar no tiene valor de serie"
+Asset Naming Series,Series de Nombres de Activos,
+BOM Variance Report,Informe de varianza BOM(Lista de Materiales)
+Cannot promote Employee with status Left,No se puede promover Empleado con estado ha salido,
+Auto repeat document updated,Repetición automática del documento actualizado,
diff --git a/erpnext/translations/es-GT.csv b/erpnext/translations/es-GT.csv
index 5d03aed..10e4e59 100644
--- a/erpnext/translations/es-GT.csv
+++ b/erpnext/translations/es-GT.csv
@@ -1,7 +1,7 @@
-DocType: Instructor Log,Other Details,Otros Detalles
-DocType: Material Request Item,Lead Time Date,Fecha de la Iniciativa
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Tiempo de ejecución en días
-apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Outstanding Amt,Saldo Pendiente
-DocType: Bank Statement Transaction Invoice Item,Outstanding Amount,Saldo Pendiente
-DocType: Payment Entry Reference,Outstanding,Pendiente
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,Lead must be set if Opportunity is made from Lead,La Iniciativa se debe establecer si la Oportunidad está hecha desde una Iniciativa
+Other Details,Otros Detalles,
+Lead Time Date,Fecha de la Iniciativa,
+Lead Time Days,Tiempo de ejecución en días,
+Outstanding Amt,Saldo Pendiente,
+Outstanding Amount,Saldo Pendiente,
+Outstanding,Pendiente,
+Lead must be set if Opportunity is made from Lead,La Iniciativa se debe establecer si la Oportunidad está hecha desde una Iniciativa,
diff --git a/erpnext/translations/es-MX.csv b/erpnext/translations/es-MX.csv
index 6997937..92479c4 100644
--- a/erpnext/translations/es-MX.csv
+++ b/erpnext/translations/es-MX.csv
@@ -1,22 +1,22 @@
-DocType: Timesheet,Total Costing Amount,Monto Total Calculado
-DocType: Leave Policy,Leave Policy Details,Detalles de Política de Licencia
-apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html +35,Mode of Payments,Forma de pago
-DocType: Student Group Student,Student Group Student,Alumno de Grupo de Estudiantes
-DocType: Delivery Note,% Installed,% Instalado
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +55,The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,La cantidad de {0} establecida en esta solicitud de pago es diferente de la cantidad calculada para todos los planes de pago: {1}. Verifique que esto sea correcto antes de enviar el documento.
-DocType: Company,Gain/Loss Account on Asset Disposal,Cuenta de ganancia/pérdida en la disposición de activos
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +550,Please enter Account for Change Amount,"Por favor, introduzca la Vuenta para el Cambio Monto"
-DocType: Loyalty Point Entry,Loyalty Point Entry,Entrada de Punto de Lealtad
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +372,Please set the Item Code first,"Por favor, primero define el Código del Artículo"
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +76,Show unclosed fiscal year's P&L balances,Mostrar saldos de Ganancias y Perdidas de año fiscal sin cerrar
-,Support Hour Distribution,Distribución de Hora de Soporte
-apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Fortaleza de Grupo Estudiante
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +197,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Por favor defina la 'Cuenta de Ganacia/Pérdida  por Ventas de Activos' en la empresa {0}
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +58,Leave Type {0} cannot be allocated since it is leave without pay,Tipo de Permiso {0} no puede ser asignado ya que es un Permiso sin paga
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +48,The payment gateway account in plan {0} is different from the payment gateway account in this payment request,La cuenta para pasarela de pago en el plan {0} es diferente de la cuenta de pasarela de pago en en esta petición de pago
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +488,Show Salary Slip,Mostrar Recibo de Nómina
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +328,Leave Without Pay does not match with approved Leave Application records,Permiso sin sueldo no coincide con los registros de Solicitud de Permiso aprobadas
-DocType: Purchase Taxes and Charges Template,"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
+Total Costing Amount,Monto Total Calculado,
+Leave Policy Details,Detalles de Política de Licencia,
+Mode of Payments,Forma de pago,
+Student Group Student,Alumno de Grupo de Estudiantes,
+% Installed,% Instalado,
+The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,La cantidad de {0} establecida en esta solicitud de pago es diferente de la cantidad calculada para todos los planes de pago: {1}. Verifique que esto sea correcto antes de enviar el documento.
+Gain/Loss Account on Asset Disposal,Cuenta de ganancia/pérdida en la disposición de activos,
+Please enter Account for Change Amount,"Por favor, introduzca la Vuenta para el Cambio Monto"
+Loyalty Point Entry,Entrada de Punto de Lealtad,
+Please set the Item Code first,"Por favor, primero define el Código del Artículo"
+Show unclosed fiscal year's P&L balances,Mostrar saldos de Ganancias y Perdidas de año fiscal sin cerrar,
+Support Hour Distribution,Distribución de Hora de Soporte
+Student Group Strength,Fortaleza de Grupo Estudiante,
+Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Por favor defina la 'Cuenta de Ganacia/Pérdida  por Ventas de Activos' en la empresa {0}
+Leave Type {0} cannot be allocated since it is leave without pay,Tipo de Permiso {0} no puede ser asignado ya que es un Permiso sin paga,
+The payment gateway account in plan {0} is different from the payment gateway account in this payment request,La cuenta para pasarela de pago en el plan {0} es diferente de la cuenta de pasarela de pago en en esta petición de pago,
+Show Salary Slip,Mostrar Recibo de Nómina,
+Leave Without Pay does not match with approved Leave Application records,Permiso sin sueldo no coincide con los registros de Solicitud de Permiso aprobadas,
+"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
 
 #### Note
 
@@ -28,7 +28,7 @@
     - This can be on **Net Total** (that is the sum of basic amount).
     - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
     - **Actual** (as mentioned).
-2. Account Head: The Account ledger under which this tax will be booked
+2. Account Head: The Account ledger under which this tax will be booked,
 3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
 4. Description: Description of the tax (that will be printed in invoices / quotes).
 5. Rate: Tax rate.
@@ -57,28 +57,28 @@
  8. Línea de referencia: Si se basa en ""Línea anterior al total"" se puede seleccionar el número de la fila que será tomado como base para este cálculo (por defecto es la fila anterior).
  9. Considerar impuesto o cargo para: En esta sección se puede especificar si el impuesto / cargo es sólo para la valoración (no una parte del total) o sólo para el total (no agrega valor al elemento) o para ambos.
  10. Añadir o deducir: Si usted quiere añadir o deducir el impuesto."
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +160,Leave Type {0} cannot be carry-forwarded,Tipo de Permiso {0} no se puede arrastar o trasladar
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +130,Gain/Loss on Asset Disposal,Ganancia/Pérdida por la venta de activos
-DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Especificar el Tipo de Cambio para convertir de una divisa a otra
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +46,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,"Sólo Solicitudes de Permiso con estado ""Aprobado"" y ""Rechazado"" puede ser presentado"
-DocType: Loyalty Point Entry,Loyalty Program,Programa de Lealtad
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +163,Source and target warehouse must be different,El almacén de origen y el de destino deben ser diferentes
-apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20,"Service Item,Type,frequency and expense amount are required","El Artículo de Servico, el Tipo, la Frecuencia y la Cantidad de Gasto son requeridos"
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +72,Gross Purchase Amount is mandatory,El Importe Bruto de Compra es obligatorio
-DocType: Stock Entry,Customer or Supplier Details,Detalle de cliente o proveedor
-DocType: Lab Test Template,Standard Selling Rate,Tarifa de Venta Estándar
-DocType: Program Enrollment,School House,Casa Escuela
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +289,Please set default account in Expense Claim Type {0},"Por favor, establezca la Cuenta predeterminada en el Tipo de Reembolso de Gastos {0}"
-apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +48,Score cannot be greater than Maximum Score,Los resultados no puede ser mayor que la Puntuación Máxima
-DocType: Item,"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.","Ejemplo: ABCD. #####. Si se establece una serie y no se menciona el número de lote en las transacciones, se creará un número de lote automático basado en esta serie. Si siempre quiere mencionar explícitamente el número de lote para este artículo, déjelo en blanco. Nota: esta configuración tendrá prioridad sobre el Prefijo de denominación de serie en Configuración de Inventario."
-apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60,Please set Company filter blank if Group By is 'Company',"Por favor, establezca el filtro de Compañía en blanco si Agrupar Por es 'Compañía'"
-DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.","Para Grupo de Estudiantes por Curso, el Curso será validado para cada Estudiante de los Cursos inscritos en la Inscripción del Programa."
-DocType: Leave Policy Detail,Leave Policy Detail,Detalles de política de Licencia
-DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Para grupo de estudiantes por lotes, el lote de estudiantes se validará para cada estudiante de la inscripción del programa."
-DocType: Subscription Plan,Payment Plan,Plan de pago
-apps/erpnext/erpnext/stock/doctype/item/item.py +731,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,No se pueden cambiar las propiedades de Variantes después de la transacción de inventario. Deberá crear un nuevo artículo para hacer esto.
-apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js +98,Stock quantity to start procedure is not available in the warehouse. Do you want to record a Stock Transfer,La cantidad de existencias para comenzar el procedimiento no está disponible en el almacén. ¿Desea registrar una transferencia de inventario?
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +259,"Company, Payment Account, From Date and To Date is mandatory","Empresa, cuenta de pago, fecha de inicio y fecha final son obligatorios"
-DocType: Leave Encashment,Leave Encashment,Cobro de Permiso
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1211,Select Items based on Delivery Date,Seleccionar Artículos según la fecha de entrega
-DocType: Salary Structure,Leave Encashment Amount Per Day,Cantidad por día para pago por Ausencia
+Leave Type {0} cannot be carry-forwarded,Tipo de Permiso {0} no se puede arrastar o trasladar,
+Gain/Loss on Asset Disposal,Ganancia/Pérdida por la venta de activos,
+Specify Exchange Rate to convert one currency into another,Especificar el Tipo de Cambio para convertir de una divisa a otra,
+Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,"Sólo Solicitudes de Permiso con estado ""Aprobado"" y ""Rechazado"" puede ser presentado"
+Loyalty Program,Programa de Lealtad,
+Source and target warehouse must be different,El almacén de origen y el de destino deben ser diferentes,
+"Service Item,Type,frequency and expense amount are required","El Artículo de Servico, el Tipo, la Frecuencia y la Cantidad de Gasto son requeridos"
+Gross Purchase Amount is mandatory,El Importe Bruto de Compra es obligatorio,
+Customer or Supplier Details,Detalle de cliente o proveedor,
+Standard Selling Rate,Tarifa de Venta Estándar,
+School House,Casa Escuela,
+Please set default account in Expense Claim Type {0},"Por favor, establezca la Cuenta predeterminada en el Tipo de Reembolso de Gastos {0}"
+Score cannot be greater than Maximum Score,Los resultados no puede ser mayor que la Puntuación Máxima,
+"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.","Ejemplo: ABCD. #####. Si se establece una serie y no se menciona el número de lote en las transacciones, se creará un número de lote automático basado en esta serie. Si siempre quiere mencionar explícitamente el número de lote para este artículo, déjelo en blanco. Nota: esta configuración tendrá prioridad sobre el Prefijo de denominación de serie en Configuración de Inventario."
+Please set Company filter blank if Group By is 'Company',"Por favor, establezca el filtro de Compañía en blanco si Agrupar Por es 'Compañía'"
+"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.","Para Grupo de Estudiantes por Curso, el Curso será validado para cada Estudiante de los Cursos inscritos en la Inscripción del Programa."
+Leave Policy Detail,Detalles de política de Licencia,
+"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Para grupo de estudiantes por lotes, el lote de estudiantes se validará para cada estudiante de la inscripción del programa."
+Payment Plan,Plan de pago,
+Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,No se pueden cambiar las propiedades de Variantes después de la transacción de inventario. Deberá crear un nuevo artículo para hacer esto.
+Stock quantity to start procedure is not available in the warehouse. Do you want to record a Stock Transfer,La cantidad de existencias para comenzar el procedimiento no está disponible en el almacén. ¿Desea registrar una transferencia de inventario?
+"Company, Payment Account, From Date and To Date is mandatory","Empresa, cuenta de pago, fecha de inicio y fecha final son obligatorios"
+Leave Encashment,Cobro de Permiso,
+Select Items based on Delivery Date,Seleccionar Artículos según la fecha de entrega,
+Leave Encashment Amount Per Day,Cantidad por día para pago por Ausencia,
diff --git a/erpnext/translations/es-NI.csv b/erpnext/translations/es-NI.csv
index dc0e9fb..28c57dc 100644
--- a/erpnext/translations/es-NI.csv
+++ b/erpnext/translations/es-NI.csv
@@ -1,16 +1,16 @@
-DocType: Tax Rule,Tax Rule,Regla Fiscal
-DocType: POS Profile,Account for Change Amount,Cuenta para el Cambio de Monto
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +873,Bill of Materials,Lista de Materiales
-apps/erpnext/erpnext/controllers/accounts_controller.py +703,'Update Stock' cannot be checked for fixed asset sale,"""Actualización de Existencia' no puede ser escogida para venta de activo fijo"
-DocType: Purchase Invoice,Tax ID,RUC
-DocType: BOM Item,Basic Rate (Company Currency),Taza Base (Divisa de la Empresa)
-DocType: Timesheet Detail,Bill,Factura
-DocType: Activity Cost,Billing Rate,Monto de Facturación
-apps/erpnext/erpnext/config/learn.py +87,Opening Accounting Balance,Apertura de Saldos Contables
-apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +97,Tax Rule Conflicts with {0},Regla Fiscal en conflicto con {0}
-DocType: Tax Rule,Billing County,Municipio de Facturación
-DocType: Sales Invoice Timesheet,Billing Hours,Horas de Facturación
-DocType: Timesheet,Billing Details,Detalles de Facturación
-DocType: Tax Rule,Billing State,Región de Facturación
-DocType: Purchase Order Item,Billed Amt,Monto Facturado
-DocType: Item Tax,Tax Rate,Tasa de Impuesto
+Tax Rule,Regla Fiscal,
+Account for Change Amount,Cuenta para el Cambio de Monto,
+Bill of Materials,Lista de Materiales,
+'Update Stock' cannot be checked for fixed asset sale,"""Actualización de Existencia' no puede ser escogida para venta de activo fijo"
+Tax ID,RUC,
+Basic Rate (Company Currency),Taza Base (Divisa de la Empresa)
+Bill,Factura,
+Billing Rate,Monto de Facturación,
+Opening Accounting Balance,Apertura de Saldos Contables,
+Tax Rule Conflicts with {0},Regla Fiscal en conflicto con {0}
+Billing County,Municipio de Facturación,
+Billing Hours,Horas de Facturación,
+Billing Details,Detalles de Facturación,
+Billing State,Región de Facturación,
+Billed Amt,Monto Facturado,
+Tax Rate,Tasa de Impuesto,
diff --git a/erpnext/translations/es-PE.csv b/erpnext/translations/es-PE.csv
index de11c72..05f14cc 100644
--- a/erpnext/translations/es-PE.csv
+++ b/erpnext/translations/es-PE.csv
@@ -1,1024 +1,1024 @@
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +22,This is a root sales person and cannot be edited.,Se trata de una persona de las ventas raíz y no se puede editar .
-apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Establecer Valores Predeterminados , como Empresa , Moneda, Año Fiscal Actual, etc"
-DocType: HR Settings,Employee Settings,Configuración del Empleado
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +218,Serial No {0} does not belong to Item {1},Número de orden {0} no pertenece al elemento {1}
-DocType: Naming Series,User must always select,Usuario elegirá siempre
-DocType: Account,Cost of Goods Sold,Costo de las Ventas
-apps/erpnext/erpnext/accounts/utils.py +74,{0} {1} not in any active Fiscal Year.,{0} {1} no en algún año fiscal activo.
-DocType: Sales Invoice,Packing List,Lista de Envío
-DocType: Packing Slip,From Package No.,Del Paquete N º
-,Quotation Trends,Tendencias de Cotización
-DocType: Purchase Invoice Item,Purchase Order Item,Articulos de la Orden de Compra
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +68,Avg. Buying Rate,Promedio de Compra
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +398,Serial No {0} created,Número de orden {0} creado
-DocType: Item,If subcontracted to a vendor,Si es sub-contratado a un vendedor
-DocType: Work Order Operation,"in Minutes
+This is a root sales person and cannot be edited.,Se trata de una persona de las ventas raíz y no se puede editar .
+"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Establecer Valores Predeterminados , como Empresa , Moneda, Año Fiscal Actual, etc"
+Employee Settings,Configuración del Empleado,
+Serial No {0} does not belong to Item {1},Número de orden {0} no pertenece al elemento {1}
+User must always select,Usuario elegirá siempre,
+Cost of Goods Sold,Costo de las Ventas,
+{0} {1} not in any active Fiscal Year.,{0} {1} no en algún año fiscal activo.
+Packing List,Lista de Envío,
+From Package No.,Del Paquete N o,
+Quotation Trends,Tendencias de Cotización,
+Purchase Order Item,Articulos de la Orden de Compra,
+Avg. Buying Rate,Promedio de Compra,
+Serial No {0} created,Número de orden {0} creado,
+If subcontracted to a vendor,Si es sub-contratado a un vendedor,
+"in Minutes,
 Updated via 'Time Log'",En minutos actualizado a través de 'Bitácora de tiempo'
-DocType: Maintenance Visit,Maintenance Time,Tiempo de Mantenimiento
-DocType: Issue,Opening Time,Tiempo de Apertura
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +873,Bill of Materials,Lista de materiales (LdM)
-DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Función Permitida para Establecer Cuentas Congeladas y Editar Entradas Congeladas
-DocType: Activity Cost,Billing Rate,Tasa de facturación
-DocType: BOM Update Tool,The new BOM after replacement,La nueva Solicitud de Materiales después de la sustitución
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +228,Row {0}: Debit entry can not be linked with a {1},Fila {0}: Débito no puede vincularse con {1}
-DocType: Journal Entry,Print Heading,Título de impresión
-DocType: Workstation,Electricity Cost,Coste de electricidad
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +101,Commission on Sales,Comisión de Ventas
-DocType: Travel Request,Costing,Costeo
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45,Retail & Wholesale,Venta al por menor y al por mayor
-DocType: Company,Default Holiday List,Listado de vacaciones / feriados predeterminados
-DocType: Bank Statement Transaction Invoice Item,Journal Entry,Asientos Contables
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +387,Completed Qty can not be greater than 'Qty to Manufacture',La cantidad completada no puede ser mayor que la cantidad a producir
-DocType: Leave Block List,Stop users from making Leave Applications on following days.,Deje que los usuarios realicen Solicitudes de Vacaciones en los siguientes días .
-DocType: Sales Invoice Item,Qty as per Stock UOM,Cantidad de acuerdo a la Unidad de Medida del Inventario
-DocType: Item,Manufacture,Manufactura
-DocType: Sales Invoice,Write Off Outstanding Amount,Cantidad de desajuste
-apps/erpnext/erpnext/config/selling.py +36,Manage Customer Group Tree.,Administrar el listado de las categorías de clientes
-apps/erpnext/erpnext/public/js/setup_wizard.js +28,Retail,venta al por menor
-DocType: Purchase Receipt,Time at which materials were received,Momento en que se recibieron los materiales
-DocType: Project,Expected End Date,Fecha de finalización prevista
-DocType: HR Settings,HR Settings,Configuración de Recursos Humanos
-apps/erpnext/erpnext/setup/doctype/company/company.js +133,Delete all the Transactions for this Company,Eliminar todas las transacciones para esta empresa
-apps/erpnext/erpnext/setup/doctype/company/company.py +53,Abbreviation is mandatory,La Abreviación es mandatoria
-DocType: Item,End of Life,Final de la Vida
-,Reqd By Date,Solicitado Por Fecha
-DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Calculo de Salario basado en los Ingresos y la Deducción.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +113,You are not authorized to set Frozen value,Usted no está autorizado para fijar el valor congelado
-DocType: Department,Leave Approver,Supervisor de Vacaciones
-DocType: Packing Slip,Package Weight Details,Peso Detallado del Paquete
-DocType: Maintenance Schedule,Generate Schedule,Generar Horario
-DocType: Employee External Work History,Employee External Work History,Historial de Trabajo Externo del Empleado
-DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Aquí usted puede mantener los detalles de la familia como el nombre y ocupación de los padres, cónyuge e hijos"
-DocType: Task,depends_on,depende de
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +165,Secured Loans,Préstamos Garantizados
-apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,This is a root territory and cannot be edited.,Este es un territorio raíz y no se puede editar .
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +975,Make Supplier Quotation,Crear cotización de proveedor
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Repita los ingresos de los clientes
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22,New Cost Center Name,Nombre de Nuevo Centro de Coste
-DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Si se selecciona, el importe del impuesto se considerará como ya incluido en el Monto  a Imprimir"
-DocType: Purchase Invoice,Purchase Taxes and Charges,Impuestos de Compra y Cargos
-apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15,This is an example website auto-generated from ERPNext,Este es un sitio web ejemplo generado por automáticamente por ERPNext
-DocType: Job Card,WIP Warehouse,WIP Almacén
-DocType: Job Card,Actual Start Date,Fecha de inicio actual
-apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js +24,Make Journal Entry,Haga Comprobante de Diario
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +141,Contract End Date must be greater than Date of Joining,La Fecha de Finalización de Contrato debe ser mayor que la Fecha de la Firma
-DocType: Sales Invoice Item,Delivery Note Item,Articulo de la Nota de Entrega
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',Cliente requiere para ' Customerwise descuento '
-apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Oportunidades de venta
-DocType: Delivery Note Item,Against Sales Order Item,Contra la Orden de Venta de Artículos
-DocType: Quality Inspection,Sample Size,Tamaño de la muestra
-DocType: Purchase Invoice,Terms and Conditions1,Términos y Condiciones 1
-DocType: Authorization Rule,Customerwise Discount,Customerwise Descuento
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74,Row {0}:Start Date must be before End Date,Fila {0}: Fecha de inicio debe ser anterior Fecha de finalización
-DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
+Maintenance Time,Tiempo de Mantenimiento,
+Opening Time,Tiempo de Apertura,
+Bill of Materials,Lista de materiales (LdM)
+Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Función Permitida para Establecer Cuentas Congeladas y Editar Entradas Congeladas,
+Billing Rate,Tasa de facturación,
+The new BOM after replacement,La nueva Solicitud de Materiales después de la sustitución,
+Row {0}: Debit entry can not be linked with a {1},Fila {0}: Débito no puede vincularse con {1}
+Print Heading,Título de impresión,
+Electricity Cost,Coste de electricidad,
+Commission on Sales,Comisión de Ventas,
+Costing,Costeo,
+Retail & Wholesale,Venta al por menor y al por mayor,
+Default Holiday List,Listado de vacaciones / feriados predeterminados,
+Journal Entry,Asientos Contables,
+Completed Qty can not be greater than 'Qty to Manufacture',La cantidad completada no puede ser mayor que la cantidad a producir,
+Stop users from making Leave Applications on following days.,Deje que los usuarios realicen Solicitudes de Vacaciones en los siguientes días .
+Qty as per Stock UOM,Cantidad de acuerdo a la Unidad de Medida del Inventario,
+Manufacture,Manufactura,
+Write Off Outstanding Amount,Cantidad de desajuste,
+Manage Customer Group Tree.,Administrar el listado de las categorías de clientes,
+Retail,venta al por menor,
+Time at which materials were received,Momento en que se recibieron los materiales,
+Expected End Date,Fecha de finalización prevista,
+HR Settings,Configuración de Recursos Humanos,
+Delete all the Transactions for this Company,Eliminar todas las transacciones para esta empresa,
+Abbreviation is mandatory,La Abreviación es mandatoria,
+End of Life,Final de la Vida,
+Reqd By Date,Solicitado Por Fecha,
+Salary breakup based on Earning and Deduction.,Calculo de Salario basado en los Ingresos y la Deducción.
+You are not authorized to set Frozen value,Usted no está autorizado para fijar el valor congelado,
+Leave Approver,Supervisor de Vacaciones,
+Package Weight Details,Peso Detallado del Paquete,
+Generate Schedule,Generar Horario,
+Employee External Work History,Historial de Trabajo Externo del Empleado,
+"Here you can maintain family details like name and occupation of parent, spouse and children","Aquí usted puede mantener los detalles de la familia como el nombre y ocupación de los padres, cónyuge e hijos"
+depends_on,depende de,
+Secured Loans,Préstamos Garantizados,
+This is a root territory and cannot be edited.,Este es un territorio raíz y no se puede editar .
+Make Supplier Quotation,Crear cotización de proveedor,
+Repeat Customer Revenue,Repita los ingresos de los clientes,
+New Cost Center Name,Nombre de Nuevo Centro de Coste,
+"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Si se selecciona, el importe del impuesto se considerará como ya incluido en el Monto  a Imprimir"
+Purchase Taxes and Charges,Impuestos de Compra y Cargos,
+This is an example website auto-generated from ERPNext,Este es un sitio web ejemplo generado por automáticamente por ERPNext,
+WIP Warehouse,WIP Almacén,
+Actual Start Date,Fecha de inicio actual,
+Make Journal Entry,Haga Comprobante de Diario,
+Contract End Date must be greater than Date of Joining,La Fecha de Finalización de Contrato debe ser mayor que la Fecha de la Firma,
+Delivery Note Item,Articulo de la Nota de Entrega,
+Customer required for 'Customerwise Discount',Cliente requiere para ' Customerwise descuento '
+Potential opportunities for selling.,Oportunidades de venta,
+Against Sales Order Item,Contra la Orden de Venta de Artículos,
+Sample Size,Tamaño de la muestra,
+Terms and Conditions1,Términos y Condiciones 1,
+Customerwise Discount,Customerwise Descuento,
+Row {0}:Start Date must be before End Date,Fila {0}: Fecha de inicio debe ser anterior Fecha de finalización,
+"Tax detail table fetched from item master as a string and stored in this field.
 Used for Taxes and Charges","Tabla de detalle de Impuesto descargada de maestro de artículos como una cadena y almacenada en este campo.
  Se utiliza para las tasas y cargos"
-DocType: BOM,Operating Cost,Costo de Funcionamiento
-apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Target,Totales del Objetivo
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +57,"Can not filter based on Voucher No, if grouped by Voucher","No se puede filtrar en función al 'No. de comprobante', si esta agrupado por 'nombre'"
-DocType: Naming Series,Help HTML,Ayuda HTML
-DocType: Work Order Operation,Actual Operation Time,Tiempo de operación actual
-DocType: Sales Order,To Deliver and Bill,Para Entregar y Bill
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +534,Warehouse required for stock Item {0},Almacén requerido para la acción del artículo {0}
-DocType: Territory,Territory Targets,Territorios Objetivos
-DocType: Warranty Claim,Warranty / AMC Status,Garantía / AMC Estado
-DocType: Additional Salary,Employee Name,Nombre del Empleado
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Programa de mantenimiento no se genera para todos los artículos. Por favor, haga clic en ¨ Generar Programación¨"
-DocType: Email Digest,New Sales Orders,Nueva Órden de Venta
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,Software
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +31,Earnest Money,Dinero Ganado
-DocType: Quotation,Term Details,Detalles de los Terminos
-DocType: Crop,Target Warehouse,Inventario Objetivo
-DocType: Packing Slip,Net Weight UOM,Unidad de Medida Peso Neto
-apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Fila # {0}: conflictos con fila {1}
-DocType: BOM Operation,Operation Time,Tiempo de funcionamiento
-DocType: Leave Application,Leave Balance Before Application,Vacaciones disponibles antes de la solicitud
-DocType: Naming Series,Set prefix for numbering series on your transactions,Establezca los prefijos de sus transacciones
-DocType: Serial No,Under AMC,Bajo AMC
-DocType: Item,Warranty Period (in days),Período de garantía ( en días)
-DocType: Email Digest,Next email will be sent on:,Siguiente correo electrónico será enviado el:
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67,Case No(s) already in use. Try from Case No {0},Nº de caso ya en uso. Intente Nº de caso {0}
-apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,Objetivo On
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Para no aplicar la Regla de Precios en una transacción en particular, todas las Reglas de Precios aplicables deben ser desactivadas."
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +166,"Sorry, Serial Nos cannot be merged","Lo sentimos , Nos de serie no se puede fusionar"
-DocType: Manufacturing Settings,Manufacturing Settings,Ajustes de Manufactura
-DocType: Appraisal Template,Appraisal Template Title,Titulo de la Plantilla deEvaluación
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +162,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Fila {0}: Por favor, consulte ""¿Es Avance 'contra la Cuenta {1} si se trata de una entrada con antelación."
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +44,Capital Equipments,Maquinaria y Equipos
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +273,{0} {1} is not submitted,{0} {1} no esta presentado
-DocType: Salary Slip,Earning & Deduction,Ganancia y Descuento
-DocType: Employee,Leave Encashed?,Vacaciones Descansadas?
-DocType: Email Digest,Send regular summary reports via Email.,Enviar informes periódicos resumidos por correo electrónico.
-apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,"""Basado en"" y ""Agrupar por"" no pueden ser el mismo"
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39,Net pay cannot be negative,Salario neto no puede ser negativo
-DocType: Company,Phone No,Teléfono No
-DocType: QuickBooks Migrator,Default Cost Center,Centro de coste por defecto
-DocType: Education Settings,Employee Number,Número del Empleado
-DocType: Opportunity,Customer / Lead Address,Cliente / Dirección de Oportunidad
-DocType: Quotation,In Words will be visible once you save the Quotation.,En palabras serán visibles una vez que guarde la cotización.
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +287,Installation Note {0} has already been submitted,La nota de instalación {0} ya se ha presentado
-apps/erpnext/erpnext/config/selling.py +105,Manage Territory Tree.,Vista en árbol para la administración de los territorios
-apps/erpnext/erpnext/stock/utils.py +231,Serial number {0} entered more than once,Número de serie {0} entraron más de una vez
-apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +72,Receiver List is empty. Please create Receiver List,"Lista de receptores está vacía. Por favor, cree Lista de receptores"
-DocType: Target Detail,Target Detail,Objetivo Detalle
-DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Plantillas de Cargos e Impuestos
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145,Current Liabilities,Pasivo Corriente
-apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,"Títulos para plantillas de impresión, por ejemplo, Factura Proforma."
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Freight and Forwarding Charges,Cargos por transporte de mercancías y transito
-apps/erpnext/erpnext/setup/doctype/company/company.js +126,Successfully deleted all transactions related to this company!,Eliminado correctamente todas las transacciones relacionadas con esta empresa!
-apps/erpnext/erpnext/controllers/stock_controller.py +231,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,"Cuenta de Gastos o Diferencia es obligatorio para el elemento {0} , ya que impacta el valor del stock"
-DocType: Account,Credit,Crédito
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,90-Mayor
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +26,Root cannot have a parent cost center,Raíz no puede tener un centro de costes de los padres
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +432,Accounting Entry for Stock,Asiento contable de inventario
-DocType: Project,Total Purchase Cost (via Purchase Invoice),Coste total de compra (mediante compra de la factura)
-apps/erpnext/erpnext/controllers/buying_controller.py +399,Row {0}: Conversion Factor is mandatory,Fila {0}: Factor de conversión es obligatoria
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +928,Purchase Receipt,Recibos de Compra
-DocType: Pricing Rule,Disable,Inhabilitar
-DocType: Item Website Specification,Table for Item that will be shown in Web Site,Tabla de Artículo que se muestra en el Sitio Web
-DocType: Attendance,Leave Type,Tipo de Vacaciones
-DocType: Pricing Rule,Applicable For,Aplicable para
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156,Start date should be less than end date for Item {0},La fecha de inicio debe ser menor que la fecha de finalización para el punto {0}
-DocType: Purchase Invoice Item,Rate (Company Currency),Precio (Moneda Local)
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +105,Convert to Group,Convertir al Grupo
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44,{0} payment entries can not be filtered by {1},{0} registros de pago no se pueden filtrar por {1}
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +284,Serial No {0} not in stock,Número de orden {0} no está en stock
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94,Ref Date,Fecha Ref
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Balanza de Estado de Cuenta Bancario según Libro Mayor
-DocType: Naming Series,Setup Series,Serie de configuración
-DocType: Work Order Operation,Actual Start Time,Hora de inicio actual
-apps/erpnext/erpnext/stock/doctype/item/item.py +523,Barcode {0} already used in Item {1},El código de barras {0} ya se utiliza en el elemento {1}
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31,Health Care,Cuidado de la Salud
-DocType: Item,Manufacturer Part Number,Número de Pieza del Fabricante
-DocType: Item Reorder,Re-Order Level,Reordenar Nivel
-DocType: Customer,Sales Team Details,Detalles del equipo de ventas
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +657,Sales Order {0} is not submitted,Órden de Venta {0} no esta presentada
-apps/erpnext/erpnext/utilities/transaction_base.py +126,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Fila # {0}: Tasa debe ser el mismo que {1}: {2} ({3} / {4})
-apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Pedidos en firme de los clientes.
-DocType: Warranty Claim,Service Address,Dirección del Servicio
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Aplicación de Fondos (Activos )
-DocType: Pricing Rule,Discount on Price List Rate (%),Descuento sobre la tarifa del listado de precios (%)
-apps/erpnext/erpnext/public/js/setup_wizard.js +110,The name of your company for which you are setting up this system.,El nombre de su empresa para la que va a configurar el sistema.
-DocType: Account,Frozen,Congelado
-DocType: Contract,HR Manager,Gerente de Recursos Humanos
-apps/erpnext/erpnext/controllers/accounts_controller.py +545,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Advertencia : El sistema no comprobará sobrefacturación desde monto para el punto {0} en {1} es cero
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +17,Either target qty or target amount is mandatory.,Cualquiera Cantidad de destino o importe objetivo es obligatoria.
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +79,Row # {0}: Returned Item {1} does not exists in {2} {3},Fila # {0}: El artículo vuelto {1} no existe en {2} {3}
-DocType: Production Plan,Not Started,Sin comenzar
-DocType: Healthcare Practitioner,Default Currency,Moneda Predeterminada
-apps/erpnext/erpnext/accounts/doctype/account/account.js +37,This is a root account and cannot be edited.,Esta es una cuenta raíz y no se puede editar .
-,Requested Items To Be Transferred,Artículos solicitados para ser transferido
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +267,Purchase Receipt {0} is not submitted,Recibo de Compra {0} no se presenta
-apps/erpnext/erpnext/controllers/accounts_controller.py +907,Account: {0} with currency: {1} can not be selected,Cuenta: {0} con moneda: {1} no puede ser seleccionada
-DocType: Opening Invoice Creation Tool,Sales,Venta
-DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Monto adicional de descuento (Moneda de la compañía)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +164,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Fila {0}: El pago de Compra/Venta siempre debe estar marcado como anticipo
-DocType: Department,Leave Approvers,Supervisores de Vacaciones
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +187,Please specify a valid Row ID for row {0} in table {1},"Por favor, especifique un ID de fila válida para la fila {0} en la tabla {1}"
-DocType: Customer Group,Parent Customer Group,Categoría de cliente principal
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +139,Total Outstanding Amount,Total Monto Pendiente
-DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Seleccione Distribución Mensual de distribuir de manera desigual a través de objetivos meses.
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +91,You need to enable Shopping Cart,Necesita habilitar Carito de Compras
-DocType: Leave Control Panel,New Leaves Allocated (In Days),Nuevas Vacaciones Asignados (en días)
-DocType: Employee,Rented,Alquilado
-DocType: Sales Invoice,Shipping Address Name,Dirección de envío Nombre
-DocType: Item,Moving Average,Promedio Movil
-,Qty to Deliver,Cantidad para Ofrecer
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +179,Row #{0}: Please specify Serial No for Item {1},"Fila # {0}: Por favor, especifique No de Serie de artículos {1}"
-apps/erpnext/erpnext/setup/doctype/company/company.js +111,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,"Por favor, asegúrese que realmente desea borrar todas las transacciones de esta compañía. Sus datos maestros permanecerán intactos. Esta acción no se puede deshacer."
-DocType: Shopping Cart Settings,Shopping Cart Settings,Compras Ajustes
-DocType: BOM,Raw Material Cost,Costo de la Materia Prima
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +175,A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Existe una categoría de cliente con el mismo nombre, por favor cambie el nombre del cliente o cambie el nombre de la categoría"
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +165,Quotation {0} is cancelled,Cotización {0} se cancela
-apps/erpnext/erpnext/controllers/stock_controller.py +341,Quality Inspection required for Item {0},Inspección de la calidad requerida para el articulo {0}
-apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,¿Qué hace?
-DocType: Task,Actual Time (in Hours),Tiempo actual (En horas)
-apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Hacer Orden de Venta
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +157,Doc Type,Tipo Doc.
-apps/erpnext/erpnext/utilities/user_progress.py +67,List a few of your customers. They could be organizations or individuals.,Enumere algunos de sus clientes. Pueden ser organizaciones o individuos.
-DocType: Item Customer Detail,Ref Code,Código Referencia
-DocType: Item Default,Default Selling Cost Center,Centros de coste por defecto
-DocType: Leave Block List,Leave Block List Allowed,Lista de Bloqueo de Vacaciones Permitida
-DocType: Quality Inspection,Report Date,Fecha del Informe
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +145,Purchase Invoice {0} is already submitted,Factura de Compra {0} ya existe
-DocType: Purchase Invoice,Currency and Price List,Divisa y Lista de precios
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Activo Corriente
-DocType: Item Reorder,Re-Order Qty,Reordenar Cantidad
-DocType: Department,Days for which Holidays are blocked for this department.,Días para los que Días Feriados se bloquean para este departamento .
-DocType: Project,Customer Details,Datos del Cliente
-DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,**Año Fiscal** representa un 'Ejercicio Financiero'. Los asientos contables y otras transacciones importantes se registran contra **Año Fiscal**
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Cantidad actual es obligatoria
-DocType: Stock Reconciliation,Stock Reconciliation,Reconciliación de Inventario
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +50,Score must be less than or equal to 5,Puntuación debe ser menor o igual a 5
-DocType: Purchase Taxes and Charges,On Previous Row Total,En la Anterior Fila Total
-DocType: Stock Entry Detail,Serial No / Batch,N º de serie / lote
-DocType: Purchase Order Item,Supplier Quotation Item,Articulo de la Cotización del Proveedor
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15,Brokerage,Brokerage
-DocType: Opportunity,Opportunity From,Oportunidad De
-DocType: Supplier Quotation,Supplier Address,Dirección del proveedor
-DocType: Purchase Order Item,Expected Delivery Date,Fecha Esperada de Envio
-DocType: Product Bundle,Parent Item,Artículo Principal
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98,Software Developer,Desarrollador de Software
-DocType: Item,Website Item Groups,Grupos de Artículos del Sitio Web
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Marketing Expenses,Gastos de Comercialización
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99,"Cannot declare as lost, because Quotation has been made.","No se puede declarar como perdido , porque la cotización ha sido hecha."
-DocType: Leave Allocation,New Leaves Allocated,Nuevas Vacaciones Asignadas
-apps/erpnext/erpnext/utilities/user_progress.py +252,user@example.com,user@example.com
-DocType: BOM Explosion Item,Source Warehouse,fuente de depósito
-apps/erpnext/erpnext/public/js/templates/contact_list.html +34,No contacts added yet.,No se han añadido contactos todavía
-apps/erpnext/erpnext/accounts/doctype/account/account.py +163,Root Type is mandatory,Tipo Root es obligatorio
-DocType: Patient Appointment,Scheduled,Programado
-DocType: Salary Component,Depends on Leave Without Pay,Depende de ausencia sin pago
-apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +34,Total Paid Amt,Total Pagado Amt
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,'Días desde el último pedido' debe ser mayor o igual a cero
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1161,For Warehouse,Por almacén
-,Purchase Order Items To Be Received,Productos de la Orden de Compra a ser Recibidos
-DocType: Notification Control,Delivery Note Message,Mensaje de la Nota de Entrega
-DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Coste materias primas suministradas
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +578,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},linea No. {0}: El importe no puede ser mayor que el reembolso pendiente {1}. El importe pendiente es {2}
-DocType: Item,Synced With Hub,Sincronizado con Hub
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +32,Cost Center with existing transactions can not be converted to ledger,Centro de Costos de las transacciones existentes no se puede convertir en el libro mayor
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1389,Please enter Item Code to get batch no,"Por favor, ingrese el código del producto para obtener el No. de lote"
-apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +49,Series is mandatory,Serie es obligatorio
-,Item Shortage Report,Reportar carencia de producto
-DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Grado en el que la lista de precios en moneda se convierte en la moneda base del cliente
-DocType: Stock Entry,Sales Invoice No,Factura de Venta No
-DocType: HR Settings,Don't send Employee Birthday Reminders,En enviar recordatorio de cumpleaños del empleado
-,Ordered Items To Be Delivered,Artículos pedidos para ser entregados
-apps/erpnext/erpnext/config/accounts.py +543,Point-of-Sale Profile,Perfiles del Punto de Venta POS
-apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,la lista de precios debe ser aplicable para comprar o vender
-DocType: Purchase Invoice Item,Serial No,Números de Serie
-,Bank Reconciliation Statement,Extractos Bancarios
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +506,{0} is mandatory for Item {1},{0} es obligatorio para el producto {1}
-DocType: Item,Copy From Item Group,Copiar de Grupo de Elementos
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +187,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) no puede ser mayor que cantidad planificada ({2}) en la Orden de Producción {3}
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +132,Date of Joining must be greater than Date of Birth,Fecha de acceso debe ser mayor que Fecha de Nacimiento
-DocType: Buying Settings,Settings for Buying Module,Ajustes para la compra de módulo
-DocType: Sales Person,Sales Person Targets,Metas de Vendedor
-apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Condiciones contractuales estándar para ventas y compras.
-DocType: Clinical Procedure Item,Actual Qty (at source/target),Cantidad Actual (en origen/destino)
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +70,Privilege Leave,Permiso con Privilegio
-DocType: Cost Center,Stock User,Foto del usuario
-DocType: Purchase Taxes and Charges,On Previous Row Amount,En la Fila Anterior de Cantidad
-DocType: Appraisal Goal,Weightage (%),Coeficiente de ponderación (% )
-DocType: Serial No,Creation Time,Momento de la creación
-DocType: Stock Entry,Default Source Warehouse,Origen predeterminado Almacén
-DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Plantilla de Cargos e Impuestos sobre Ventas
-DocType: Employee,Educational Qualification,Capacitación Académica
-DocType: Cashier Closing,From Time,Desde fecha
-DocType: Employee,Health Concerns,Preocupaciones de salud
-DocType: Landed Cost Item,Purchase Receipt Item,Recibo de Compra del Artículo
-apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Nombre o Email es obligatorio
-apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +19,Transactions can only be deleted by the creator of the Company,Las transacciones sólo pueden ser borrados por el creador de la Compañía
-DocType: Cost Center,Parent Cost Center,Centro de Costo Principal
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Préstamos y anticipos (Activos)
-apps/erpnext/erpnext/hooks.py +115,Shipments,Los envíos
-apps/erpnext/erpnext/controllers/buying_controller.py +196,Please enter 'Is Subcontracted' as Yes or No,"Por favor, introduzca si 'Es Subcontratado' o no"
-apps/erpnext/erpnext/setup/doctype/company/company.py +56,Abbreviation already used for another company,La Abreviación ya está siendo utilizada para otra compañía
-DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Orden de Compra del Artículo Suministrado
-DocType: Selling Settings,Sales Order Required,Orden de Ventas Requerida
-DocType: Request for Quotation Item,Required Date,Fecha Requerida
-DocType: Manufacturing Settings,Allow Overtime,Permitir horas extras
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +154,Reference No is mandatory if you entered Reference Date,Referencia No es obligatorio si introdujo Fecha de Referencia
-DocType: Pricing Rule,Pricing Rule,Reglas de Precios
-DocType: Project Task,View Task,Vista de tareas
-apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +26,`Freeze Stocks Older Than` should be smaller than %d days.,`Congelar Inventarios Anteriores a` debe ser menor que %d días .
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +91,Purchase Order number required for Item {0},Número de la Orden de Compra se requiere para el elemento {0}
-apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,Crear reglas para restringir las transacciones basadas en valores .
-DocType: Purchase Order Item Supplied,Raw Material Item Code,Materia Prima Código del Artículo
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1156,Supplier Quotation,Cotizaciónes a Proveedores
-apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},Existe un costo de actividad para el empleado {0} contra el tipo de actividad - {1}
-DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Establecer objetivos artículo grupo que tienen para este vendedor.
-DocType: Stock Entry,Total Value Difference (Out - In),Diferencia  (Salidas - Entradas)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +648,BOM and Manufacturing Quantity are required,Se requiere la lista de materiales (LdM) y cantidad a fabricar.
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +622,Product Bundle,Conjunto/Paquete de productos
-DocType: Material Request,Requested For,Solicitados para
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +396,{0} against Sales Invoice {1},{0} contra Factura de Ventas {1}
-DocType: Production Plan,Select Items,Seleccione Artículos
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +257,Row {0}: {1} {2} does not match with {3},Fila {0}: {1} {2} no coincide con {3}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +391,Quality Management,Gestión de la Calidad
-apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Los detalles de las operaciones realizadas.
-DocType: Quality Inspection Reading,Quality Inspection Reading,Lectura de Inspección de Calidad
-DocType: Purchase Invoice Item,Net Amount (Company Currency),Importe neto (moneda de la compañía)
-DocType: Sales Order,Track this Sales Order against any Project,Seguir este de órdenes de venta en contra de cualquier proyecto
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +42,"Selling must be checked, if Applicable For is selected as {0}","Ventas debe ser seleccionado, si se selecciona Aplicable Para como {0}"
-DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Mantener misma tasa durante todo el ciclo de ventas
-DocType: Employee External Work History,Salary,Salario
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +152,Stock Liabilities,Inventario de Pasivos
-DocType: Shipping Rule,Shipping Rule Label,Regla Etiqueta de envío
-apps/erpnext/erpnext/stock/doctype/item/item.js +57,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,Este artículo es una plantilla y no se puede utilizar en las transacciones. Atributos artículo se copiarán en las variantes menos que se establece 'No Copy'
-DocType: Target Detail,Target  Amount,Monto Objtetivo
-,S.O. No.,S.O. No.
-DocType: Expense Claim Detail,Sanctioned Amount,importe sancionado
-DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Si la cuenta está congelada , las entradas se les permite a los usuarios restringidos."
-DocType: Sales Invoice,Sales Taxes and Charges,Los impuestos y cargos de venta
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +46,Warehouse {0} can not be deleted as quantity exists for Item {1},Almacén {0} no se puede eliminar mientras exista cantidad de artículo {1}
-DocType: Salary Slip,Bank Account No.,Número de Cuenta Bancaria
-DocType: Shipping Rule,Shipping Account,cuenta Envíos
-DocType: Item Group,Parent Item Group,Grupo Principal de Artículos
-DocType: Serial No,Warranty Period (Days),Período de garantía ( Días)
-DocType: Selling Settings,Campaign Naming By,Nombramiento de la Campaña Por
-DocType: Material Request,Terms and Conditions Content,Términos y Condiciones Contenido
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +233,Serial No {0} does not belong to Warehouse {1},Número de orden {0} no pertenece al Almacén {1}
-DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Compras Regla de envío
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +37,Make Payment Entry,Registrar pago
-DocType: Maintenance Schedule Detail,Scheduled Date,Fecha prevista
-DocType: Material Request,% Ordered,% Pedido
-apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Expected Start Date' can not be greater than 'Expected End Date',La 'Fecha de inicio estimada' no puede ser mayor que la 'Fecha de finalización estimada'
-DocType: UOM Conversion Detail,UOM Conversion Detail,Detalle de Conversión de Unidad de Medida
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +76,"To filter based on Party, select Party Type first","Para filtrar en base a la fiesta, seleccione Partido Escriba primero"
-DocType: Delivery Stop,Contact Name,Nombre del Contacto
-DocType: Quotation,Quotation Lost Reason,Cotización Pérdida Razón
-DocType: Monthly Distribution,Monthly Distribution Percentages,Los porcentajes de distribución mensuales
-apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Plan para las visitas de mantenimiento.
-,SO Qty,SO Cantidad
-DocType: Shopping Cart Settings,Quotation Series,Serie Cotización
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Ingresos de nuevo cliente
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +139,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Caracteres especiales excepto ""-"" ""."", ""#"", y ""/"" no permitido en el nombramiento de serie"
-DocType: Assessment Plan,Schedule,Horario
-,Invoiced Amount (Exculsive Tax),Cantidad facturada ( Impuesto exclusive )
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550,Material Requests {0} created,Solicitud de Material {0} creada
-DocType: Item,Has Variants,Tiene Variantes
-DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Impuestos y Cargos Añadidos (Moneda Local)
-DocType: Customer,Buyer of Goods and Services.,Compradores de Productos y Servicios.
-DocType: Quotation Item,Stock Balance,Balance de Inventarios
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +797,Cost Center For Item with Item Code ',Centro de Costos para artículo con Código del artículo '
-DocType: POS Profile,Write Off Cost Center,Centro de costos de desajuste
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +263,Please contact to the user who have Sales Master Manager {0} role,"Por favor, póngase en contacto con el usuario con función de Gerente de Ventas {0}"
-DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Permitir a los usuarios siguientes aprobar Solicitudes de ausencia en bloques de días.
-DocType: Purchase Invoice Item,Net Rate,Tasa neta
-DocType: Purchase Taxes and Charges,Reference Row #,Referencia Fila #
-DocType: Employee Internal Work History,Employee Internal Work History,Historial de Trabajo Interno del Empleado
-DocType: Employee,Salary Mode,Modo de Salario
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,Please enter parent cost center,"Por favor, ingrese el centro de costos maestro"
-DocType: Quotation Item,Against Doctype,Contra Doctype
-apps/erpnext/erpnext/controllers/stock_controller.py +240,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: 'Centro de Costos' es obligatorio para el producto {2}
-DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),El peso neto de este paquete . ( calculados automáticamente como la suma del peso neto del material)
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Cant. Proyectada
-DocType: Bin,Moving Average Rate,Porcentaje de Promedio Movil
-apps/erpnext/erpnext/accounts/doctype/account/account.py +51,Account {0}: Parent account {1} does not exist,Cuenta {0}: Cuenta Padre {1} no existe
-DocType: Purchase Invoice,Net Total (Company Currency),Total neto (Moneda Local)
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,Delivery Note {0} must not be submitted,Nota de Entrega {0} no debe estar presentada
-,Lead Details,Iniciativas
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +59,Serial #,Serial #
-DocType: Delivery Note,Vehicle No,Vehículo No
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +214,Lower Income,Ingreso Bajo
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +210,Duplicate Serial No entered for Item {0},Duplicar Serie No existe para la partida {0}
-apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Delivered Amount,Cantidad Entregada
-DocType: Employee Transfer,New Company,Nueva Empresa
-DocType: Employee,Permanent Address Is,Dirección permanente es
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +531,Max: {0},Max: {0}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +276,{0} {1} has been modified. Please refresh.,{0} {1} ha sido modificado. Por favor actualizar.
-DocType: Item,Item Tax,Impuesto del artículo
-,Item Prices,Precios de los Artículos
-DocType: Account,Balance must be,Balance debe ser
-DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Terceros / proveedor / comisionista / afiliado / distribuidor que vende productos de empresas a cambio de una comisión.
-DocType: Manufacturing Settings,Try planning operations for X days in advance.,Trate de operaciones para la planificación de X días de antelación.
-apps/erpnext/erpnext/projects/doctype/project/project.py +84,Expected End Date can not be less than Expected Start Date,La fecha prevista de finalización no puede ser inferior a la fecha de inicio
-apps/erpnext/erpnext/accounts/general_ledger.py +178,Please mention Round Off Account in Company,"Por favor, indique la cuenta que utilizará para el redondeo--"
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},Número de orden {0} no pertenece a la nota de entrega {1}
-DocType: Target Detail,Target Qty,Cantidad Objetivo
-apps/erpnext/erpnext/stock/doctype/item/item.js +366,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Se menciona Peso, \n ¡Por favor indique ""Peso Unidad de Medida"" también"
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +244,You can not change rate if BOM mentioned agianst any item,No se puede cambiar la tasa si hay una Solicitud de Materiales contra cualquier artículo
-DocType: Account,Accounts,Contabilidad
-DocType: Workstation,per hour,por horas
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Establecer como Cerrada
-DocType: Work Order Operation,Work In Progress,Trabajos en Curso
-DocType: Accounts Settings,Credit Controller,Credit Controller
-DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Recibo de Compra del Artículo Adquirido
-DocType: SMS Center,All Sales Partner Contact,Todo Punto de Contacto de Venta
-apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Ver ofertas
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +38,Currency is required for Price List {0},Se requiere de divisas para Lista de precios {0}
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +129,Date of Birth cannot be greater than today.,La fecha de creación no puede ser mayor a la fecha de hoy.
-DocType: Employee,Reports to,Informes al
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +99,Provisional Profit / Loss (Credit),Beneficio / Pérdida (Crédito) Provisional
-DocType: Purchase Order,Ref SQ,Ref SQ
-DocType: Purchase Invoice,Total (Company Currency),Total (Compañía moneda)
-DocType: Sales Order,% of materials delivered against this Sales Order,% de materiales entregados contra la orden de venta
-DocType: Bank Reconciliation,Account Currency,Moneda de la Cuenta
-DocType: Journal Entry Account,Party Balance,Saldo de socio
-DocType: Monthly Distribution,Name of the Monthly Distribution,Nombre de la Distribución Mensual
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +538,Finished Item {0} must be entered for Manufacture type entry,El producto terminado {0} debe ser introducido para la fabricación
-apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Estado debe ser uno de {0}
-DocType: Department,Leave Block List,Lista de Bloqueo de Vacaciones
-DocType: Sales Invoice Item,Customer's Item Code,Código de artículo del Cliente
-DocType: Purchase Invoice Item,Item Tax Amount,Total de impuestos de los artículos
-DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Propósito de la Visita de Mantenimiento
-DocType: SMS Log,No of Sent SMS,No. de SMS enviados
-DocType: Account,Stock Received But Not Billed,Inventario Recibido pero no facturados
-apps/erpnext/erpnext/stock/doctype/item/item.py +191,Stores,Tiendas
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +128,Row {0}: Qty is mandatory,Fila {0}: Cantidad es obligatorio
-apps/erpnext/erpnext/accounts/doctype/account/account.py +166,Report Type is mandatory,Tipo de informe es obligatorio
-DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","Usuario del Sistema (login )ID. Si se establece , será por defecto para todas las formas de Recursos Humanos."
-apps/erpnext/erpnext/buying/utils.py +34,UOM Conversion factor is required in row {0},"El factor de conversión de la (UdM) Unidad de medida, es requerida en la linea {0}"
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,Electrónica
-DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,Cuentas (o grupos) contra el que las entradas contables se hacen y los saldos se mantienen.
-DocType: Journal Entry Account,If Income or Expense,Si es un ingreso o egreso
-apps/erpnext/erpnext/stock/doctype/item/item.py +541,Row {0}: An Reorder entry already exists for this warehouse {1},Fila {0}: Una entrada para reordenar ya existe para este almacén {1}
-DocType: Lead,Lead,Iniciativas
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +201,There is not enough leave balance for Leave Type {0},No hay suficiente saldo para Tipo de Vacaciones {0}
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Repita los Clientes
-DocType: Account,Depreciation,Depreciación
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +242,Please create Customer from Lead {0},"Por favor, cree Cliente de la Oportunidad {0}"
-DocType: Payment Request,Make Sales Invoice,Hacer Factura de Venta
-DocType: Payment Entry Reference,Supplier Invoice No,Factura del Proveedor No
-DocType: Payment Gateway Account,Payment Account,Pago a cuenta
-DocType: Journal Entry,Cash Entry,Entrada de Efectivo
-apps/erpnext/erpnext/public/js/account_tree_grid.js +65,Select Fiscal Year...,Seleccione el año fiscal ...
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +209,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Para la fila {0} en {1}. e incluir {2} en la tasa del producto, las filas {3} también deben ser incluidas"
-apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,Workstation is closed on the following dates as per Holiday List: {0},La estación de trabajo estará cerrada en las siguientes fechas según la lista de vacaciones: {0}
-DocType: Sales Person,Select company name first.,Seleccionar nombre de la empresa en primer lugar.
-DocType: Opportunity,With Items,Con artículos
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,Número de orden {0} no existe
-DocType: Purchase Receipt Item,Required By,Requerido por
-DocType: Purchase Invoice Item,Purchase Invoice Item,Factura de Compra del artículo
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +102,Quotation {0} not of type {1},Cotización {0} no es de tipo {1}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +164,Material Request {0} is cancelled or stopped,Solicitud de Material {0} cancelada o detenida
-DocType: Purchase Invoice,Supplied Items,Artículos suministrados
-DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Los usuarios con esta función pueden establecer cuentas congeladas y crear / modificar los asientos contables contra las cuentas congeladas
-DocType: Account,Debit,Débito
-apps/erpnext/erpnext/config/accounts.py +287,"e.g. Bank, Cash, Credit Card","por ejemplo Banco, Efectivo , Tarjeta de crédito"
-DocType: Work Order,Material Transferred for Manufacturing,Material transferido para fabricación
-DocType: Item Reorder,Item Reorder,Reordenar productos
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +147,Credit To account must be a Payable account,Crédito a la cuenta debe ser una cuenta por pagar
-,Lead Id,Iniciativa ID
-apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Cotizaciones recibidas de los proveedores.
-DocType: Sales Partner,Sales Partner Target,Socio de Ventas Objetivo
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Hacer Visita de Mantenimiento
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +539,Stock cannot be updated against Delivery Note {0},Inventario no puede actualizarse contra Nota de Envio {0}
-DocType: Workstation,Rent Cost,Renta Costo
-DocType: Support Settings,Issues,Problemas
-DocType: BOM Update Tool,Current BOM,Lista de materiales actual
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +78,Row # {0}:,Fila # {0}:
-DocType: Timesheet,% Amount Billed,% Monto Facturado
-DocType: BOM,Manage cost of operations,Administrar el costo de las operaciones
-DocType: Employee,Company Email,Correo de la compañía
-apps/erpnext/erpnext/config/support.py +32,Single unit of an Item.,Números de serie únicos para cada producto
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +224,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Nota de Entrega {0} debe ser cancelado antes de cancelar esta Orden Ventas
-DocType: Item Tax,Tax Rate,Tasa de Impuesto
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +127,Utility Expenses,Los gastos de servicios públicos
-DocType: Account,Parent Account,Cuenta Primaria
-DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Los mensajes de más de 160 caracteres se dividirá en varios mensajes
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158,{0}: {1} not found in Invoice Details table,{0}: {1} no se encuentra en el detalle de la factura
-DocType: Leave Control Panel,Leave blank if considered for all designations,Dejar en blanco si es considerada para todas las designaciones
-,Sales Register,Registros de Ventas
-DocType: Purchase Taxes and Charges,Account Head,Cuenta matriz
-DocType: Lab Test Template,Single,solo
-DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Enviar correos electrónicos automáticos a Contactos en transacciones SOMETER.
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,{0} is not a valid Batch Number for Item {1},{0} no es un número de lote válido para el producto {1}
-apps/erpnext/erpnext/setup/doctype/company/company.py +84,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","No se puede cambiar la moneda por defecto de la compañía, porque existen transacciones, estas deben ser canceladas para cambiar la moneda por defecto."
-apps/erpnext/erpnext/stock/doctype/item/item.py +489,Default BOM ({0}) must be active for this item or its template,La lista de materiales por defecto ({0}) debe estar activa para este producto o plantilla
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +76,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Nota: Este centro de costos es un grupo. No se pueden crear asientos contables en los grupos.
-DocType: Email Digest,How frequently?,¿Con qué frecuencia ?
-DocType: C-Form Invoice Detail,Invoice No,Factura No
-DocType: Employee,Bank A/C No.,Número de cuenta bancaria
-DocType: Delivery Note,Customer's Purchase Order No,Nº de Pedido de Compra del Cliente
-DocType: Purchase Invoice,Supplier Name,Nombre del Proveedor
-DocType: Salary Slip,Hour Rate,Hora de Cambio
-DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Cantidad del punto obtenido después de la fabricación / reempaque de cantidades determinadas de materias primas
-DocType: Journal Entry,Get Outstanding Invoices,Verifique Facturas Pendientes
-DocType: Purchase Invoice,Shipping Address,Dirección de envío
-apps/erpnext/erpnext/config/website.py +17,"Settings for online shopping cart such as shipping rules, price list etc.","Ajustes para la compra online, como las normas de envío, lista de precios, etc."
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +67,Series Updated,Series Actualizado
-DocType: Employee,Contract End Date,Fecha Fin de Contrato
-DocType: Upload Attendance,Attendance From Date,Asistencia De Fecha
-DocType: Journal Entry,Excise Entry,Entrada Impuestos Especiales
-DocType: Appraisal Template Goal,Appraisal Template Goal,Objetivo Plantilla de Evaluación
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1083,Opportunity,Oportunidades
-DocType: Additional Salary,Salary Slip,Planilla
-DocType: Account,Rate at which this tax is applied,Velocidad a la que se aplica este impuesto
-apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80,Supplier Id,Proveedor Id
-DocType: Leave Block List,Block Holidays on important days.,Bloqueo de vacaciones en días importantes.
-apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Analitico de Soporte
-DocType: Buying Settings,Subcontract,Subcontrato
-DocType: Customer,From Lead,De la iniciativa
-DocType: Bank Account,Party,Socio
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +81,Update Cost,Actualización de Costos
-DocType: Purchase Order Item,Last Purchase Rate,Tasa de Cambio de la Última Compra
-DocType: Bin,Actual Quantity,Cantidad actual
-DocType: Asset Movement,Stock Manager,Gerente
-DocType: Shipping Rule Condition,Shipping Rule Condition,Regla Condición inicial
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +179,Opening Balance Equity,Apertura de saldos de capital
-DocType: Stock Entry Detail,Stock Entry Detail,Detalle de la Entrada de Inventario
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.','Hasta Caso No.' no puede ser inferior a 'Desde el Caso No.'
-DocType: Employee,Health Details,Detalles de la Salud
-DocType: Maintenance Visit,Unscheduled,No Programada
-DocType: Instructor Log,Other Details,Otros Datos
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +46,"Buying must be checked, if Applicable For is selected as {0}","Compra debe comprobarse, si se selecciona Aplicable Para como {0}"
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +65,Period Closing Entry,Entradas de cierre de período
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,El costo de artículos comprados
-DocType: Company,Delete Company Transactions,Eliminar Transacciones de la empresa
-DocType: Purchase Order Item Supplied,Stock UOM,Unidad de Media del Inventario
-,Itemwise Recommended Reorder Level,Nivel recomendado de re-ordenamiento de producto
-DocType: Leave Type,Leave Type Name,Nombre de Tipo de Vacaciones
-DocType: Work Order Operation,Actual End Time,Hora actual de finalización
-apps/erpnext/erpnext/accounts/general_ledger.py +181,Please mention Round Off Cost Center in Company,"Por favor, indique las centro de costos para el redondeo--"
-DocType: Employee Education,Under Graduate,Bajo Graduación
-DocType: Stock Entry,Purchase Receipt No,Recibo de Compra No
-DocType: Buying Settings,Default Buying Price List,Lista de precios predeterminada
-DocType: Material Request Item,Lead Time Date,Fecha y Hora de la Iniciativa
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200,Maintenance start date can not be before delivery date for Serial No {0},Mantenimiento fecha de inicio no puede ser antes de la fecha de entrega para la Serie No {0}
-DocType: Lead,Suggestions,Sugerencias
-DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,Almacén en el que está manteniendo un balance de los artículos rechazados
-DocType: Company,Default Cost of Goods Sold Account,Cuenta de costos de venta por defecto
-DocType: Leave Type,Is Carry Forward,Es llevar adelante
-apps/erpnext/erpnext/config/setup.py +100,"Create and manage daily, weekly and monthly email digests.","Creación y gestión de resúmenes de correo electrónico diarias , semanales y mensuales."
-apps/erpnext/erpnext/config/selling.py +327,Sales Order to Payment,Órdenes de venta al Pago
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +174,Warning: Leave application contains following block dates,Advertencia: Solicitud de Renuncia contiene las siguientes fechas bloquedas
-DocType: Leave Allocation,Total Leaves Allocated,Total Vacaciones Asignadas
-apps/erpnext/erpnext/config/selling.py +153,Default settings for selling transactions.,Los ajustes por defecto para las transacciones de venta.
-DocType: Notification Control,Customize the Notification,Personalice la Notificación
-DocType: Journal Entry,Make Difference Entry,Hacer Entrada de Diferencia
-DocType: Production Plan Item,Ordered Qty,Cantidad Pedida
-apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Total (Amt)
-DocType: Journal Entry,Credit Card Entry,Introducción de tarjetas de crédito
-DocType: Authorization Rule,Applicable To (Designation),Aplicables a (Denominación )
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +194,Stock Options,Opciones sobre Acciones
-DocType: Account,Receivable,Cuenta por Cobrar
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,El campo 'Oportunidad de' es obligatorio
-apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +78,-Above,-Mayor
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +116,Office Maintenance Expenses,Gastos de Mantenimiento de Oficinas
-DocType: Blanket Order,Manufacturing,Producción
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +486,'Entries' cannot be empty,'Entradas' no puede estar vacío
-DocType: Leave Control Panel,Leave Control Panel,Salir del Panel de Control
-DocType: Monthly Distribution Percentage,Percentage Allocation,Porcentaje de asignación de
-DocType: Shipping Rule,Shipping Amount,Importe del envío
-apps/erpnext/erpnext/stock/doctype/item/item.py +74,Item Code is mandatory because Item is not automatically numbered,El código del artículo es obligatorio porque el producto no se enumera automáticamente
-DocType: Sales Invoice Item,Sales Order Item,Articulo de la Solicitud de Venta
-DocType: Sales Person,Parent Sales Person,Contacto Principal de Ventas
-DocType: Warehouse,Warehouse Contact Info,Información de Contacto del Almacén
-DocType: Supplier,Statutory info and other general information about your Supplier,Información legal y otra información general acerca de su proveedor
-apps/erpnext/erpnext/stock/doctype/item/item.py +469,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Unidad de Medida {0} se ha introducido más de una vez en la Tabla de Factores de Conversión
-apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23,From Currency and To Currency cannot be same,'Desde Moneda' y 'A Moneda' no puede ser la misma
-DocType: Shopping Cart Settings,Default settings for Shopping Cart,Ajustes por defecto para Compras
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +40,Cost Center with existing transactions can not be converted to group,Centro de Costos de las transacciones existentes no se puede convertir al grupo
-DocType: Fiscal Year,Year Start Date,Fecha de Inicio
-DocType: Buying Settings,Supplier Naming By,Ordenar proveedores por:
-DocType: Notification Control,Sales Invoice Message,Mensaje de la Factura
-DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Notificarme por Email cuando se genere una nueva solicitud de materiales
-DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Especifique la operación , el costo de operación y dar una operación única que no a sus operaciones."
-DocType: Quotation,Shopping Cart,Cesta de la compra
-DocType: Bank Guarantee,Supplier,Proveedores
-apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +39,Accounting Ledger,Libro Mayor Contable
-DocType: HR Settings,Stop Birthday Reminders,Detener recordatorios de cumpleaños
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +124,Sales Expenses,Gastos de Ventas
-DocType: Serial No,Warranty / AMC Details,Garantía / AMC Detalles
-DocType: Maintenance Schedule Item,No of Visits,No. de visitas
-DocType: Leave Application,Leave Approver Name,Nombre de Supervisor de Vacaciones
-DocType: BOM,Item Description,Descripción del Artículo
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Costo de Artículos Emitidas
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +84,Stock Expenses,Inventario de Gastos
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Tiempo de Entrega en Días
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +39,Tax Assets,Activos por Impuestos
-DocType: Maintenance Schedule,Schedules,Horarios
-DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Total de Impuestos Después Cantidad de Descuento
-DocType: Item,Has Serial No,Tiene No de Serie
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +98,Sales Order required for Item {0},Orden de Venta requerida para el punto {0}
-DocType: Serial No,Out of AMC,Fuera de AMC
-DocType: Leave Application,Apply / Approve Leaves,Aplicar / Aprobar Vacaciones
-DocType: Job Offer,Select Terms and Conditions,Selecciona Términos y Condiciones
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +660,Delivery Note {0} is not submitted,Nota de Entrega {0} no está presentada
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137,"Row {0}: To set {1} periodicity, difference between from and to date \
+Operating Cost,Costo de Funcionamiento,
+Total Target,Totales del Objetivo,
+"Can not filter based on Voucher No, if grouped by Voucher","No se puede filtrar en función al 'No. de comprobante', si esta agrupado por 'nombre'"
+Help HTML,Ayuda HTML,
+Actual Operation Time,Tiempo de operación actual,
+To Deliver and Bill,Para Entregar y Bill,
+Warehouse required for stock Item {0},Almacén requerido para la acción del artículo {0}
+Territory Targets,Territorios Objetivos,
+Warranty / AMC Status,Garantía / AMC Estado,
+Employee Name,Nombre del Empleado,
+Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Programa de mantenimiento no se genera para todos los artículos. Por favor, haga clic en ¨ Generar Programación¨"
+New Sales Orders,Nueva Órden de Venta,
+Software,Software,
+Earnest Money,Dinero Ganado,
+Term Details,Detalles de los Terminos,
+Target Warehouse,Inventario Objetivo,
+Net Weight UOM,Unidad de Medida Peso Neto,
+Row #{0}: Timings conflicts with row {1},Fila # {0}: conflictos con fila {1}
+Operation Time,Tiempo de funcionamiento,
+Leave Balance Before Application,Vacaciones disponibles antes de la solicitud,
+Set prefix for numbering series on your transactions,Establezca los prefijos de sus transacciones,
+Under AMC,Bajo AMC,
+Warranty Period (in days),Período de garantía ( en días)
+Next email will be sent on:,Siguiente correo electrónico será enviado el:
+Case No(s) already in use. Try from Case No {0},Nº de caso ya en uso. Intente Nº de caso {0}
+Target On,Objetivo On,
+"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Para no aplicar la Regla de Precios en una transacción en particular, todas las Reglas de Precios aplicables deben ser desactivadas."
+"Sorry, Serial Nos cannot be merged","Lo sentimos , Nos de serie no se puede fusionar"
+Manufacturing Settings,Ajustes de Manufactura,
+Appraisal Template Title,Titulo de la Plantilla deEvaluación,
+Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Fila {0}: Por favor, consulte ""¿Es Avance 'contra la Cuenta {1} si se trata de una entrada con antelación."
+Capital Equipments,Maquinaria y Equipos,
+{0} {1} is not submitted,{0} {1} no esta presentado,
+Earning & Deduction,Ganancia y Descuento,
+Leave Encashed?,Vacaciones Descansadas?
+Send regular summary reports via Email.,Enviar informes periódicos resumidos por correo electrónico.
+'Based On' and 'Group By' can not be same,"""Basado en"" y ""Agrupar por"" no pueden ser el mismo"
+Net pay cannot be negative,Salario neto no puede ser negativo,
+Phone No,Teléfono No,
+Default Cost Center,Centro de coste por defecto,
+Employee Number,Número del Empleado,
+Customer / Lead Address,Cliente / Dirección de Oportunidad,
+In Words will be visible once you save the Quotation.,En palabras serán visibles una vez que guarde la cotización.
+Installation Note {0} has already been submitted,La nota de instalación {0} ya se ha presentado,
+Manage Territory Tree.,Vista en árbol para la administración de los territorios,
+Serial number {0} entered more than once,Número de serie {0} entraron más de una vez,
+Receiver List is empty. Please create Receiver List,"Lista de receptores está vacía. Por favor, cree Lista de receptores"
+Target Detail,Objetivo Detalle,
+Purchase Taxes and Charges Template,Plantillas de Cargos e Impuestos,
+Current Liabilities,Pasivo Corriente,
+Titles for print templates e.g. Proforma Invoice.,"Títulos para plantillas de impresión, por ejemplo, Factura Proforma."
+Freight and Forwarding Charges,Cargos por transporte de mercancías y transito,
+Successfully deleted all transactions related to this company!,Eliminado correctamente todas las transacciones relacionadas con esta empresa!
+Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,"Cuenta de Gastos o Diferencia es obligatorio para el elemento {0} , ya que impacta el valor del stock"
+Credit,Crédito,
+90-Above,90-Mayor,
+Root cannot have a parent cost center,Raíz no puede tener un centro de costes de los padres,
+Accounting Entry for Stock,Asiento contable de inventario,
+Total Purchase Cost (via Purchase Invoice),Coste total de compra (mediante compra de la factura)
+Row {0}: Conversion Factor is mandatory,Fila {0}: Factor de conversión es obligatoria,
+Purchase Receipt,Recibos de Compra,
+Disable,Inhabilitar,
+Table for Item that will be shown in Web Site,Tabla de Artículo que se muestra en el Sitio Web,
+Leave Type,Tipo de Vacaciones,
+Applicable For,Aplicable para,
+Start date should be less than end date for Item {0},La fecha de inicio debe ser menor que la fecha de finalización para el punto {0}
+Rate (Company Currency),Precio (Moneda Local)
+Convert to Group,Convertir al Grupo,
+{0} payment entries can not be filtered by {1},{0} registros de pago no se pueden filtrar por {1}
+Serial No {0} not in stock,Número de orden {0} no está en stock,
+Ref Date,Fecha Ref,
+Bank Statement balance as per General Ledger,Balanza de Estado de Cuenta Bancario según Libro Mayor,
+Setup Series,Serie de configuración,
+Actual Start Time,Hora de inicio actual,
+Barcode {0} already used in Item {1},El código de barras {0} ya se utiliza en el elemento {1}
+Health Care,Cuidado de la Salud,
+Manufacturer Part Number,Número de Pieza del Fabricante,
+Re-Order Level,Reordenar Nivel,
+Sales Team Details,Detalles del equipo de ventas,
+Sales Order {0} is not submitted,Órden de Venta {0} no esta presentada,
+Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Fila # {0}: Tasa debe ser el mismo que {1}: {2} ({3} / {4})
+Confirmed orders from Customers.,Pedidos en firme de los clientes.
+Service Address,Dirección del Servicio,
+Application of Funds (Assets),Aplicación de Fondos (Activos )
+Discount on Price List Rate (%),Descuento sobre la tarifa del listado de precios (%)
+The name of your company for which you are setting up this system.,El nombre de su empresa para la que va a configurar el sistema.
+Frozen,Congelado,
+HR Manager,Gerente de Recursos Humanos,
+Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Advertencia : El sistema no comprobará sobrefacturación desde monto para el punto {0} en {1} es cero,
+Either target qty or target amount is mandatory.,Cualquiera Cantidad de destino o importe objetivo es obligatoria.
+Row # {0}: Returned Item {1} does not exists in {2} {3},Fila # {0}: El artículo vuelto {1} no existe en {2} {3}
+Not Started,Sin comenzar,
+Default Currency,Moneda Predeterminada,
+This is a root account and cannot be edited.,Esta es una cuenta raíz y no se puede editar .
+Requested Items To Be Transferred,Artículos solicitados para ser transferido,
+Purchase Receipt {0} is not submitted,Recibo de Compra {0} no se presenta,
+Account: {0} with currency: {1} can not be selected,Cuenta: {0} con moneda: {1} no puede ser seleccionada,
+Sales,Venta,
+Additional Discount Amount (Company Currency),Monto adicional de descuento (Moneda de la compañía)
+Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Fila {0}: El pago de Compra/Venta siempre debe estar marcado como anticipo,
+Leave Approvers,Supervisores de Vacaciones,
+Please specify a valid Row ID for row {0} in table {1},"Por favor, especifique un ID de fila válida para la fila {0} en la tabla {1}"
+Parent Customer Group,Categoría de cliente principal,
+Total Outstanding Amount,Total Monto Pendiente,
+Select Monthly Distribution to unevenly distribute targets across months.,Seleccione Distribución Mensual de distribuir de manera desigual a través de objetivos meses.
+You need to enable Shopping Cart,Necesita habilitar Carito de Compras,
+New Leaves Allocated (In Days),Nuevas Vacaciones Asignados (en días)
+Rented,Alquilado,
+Shipping Address Name,Dirección de envío Nombre,
+Moving Average,Promedio Movil,
+Qty to Deliver,Cantidad para Ofrecer,
+Row #{0}: Please specify Serial No for Item {1},"Fila # {0}: Por favor, especifique No de Serie de artículos {1}"
+Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,"Por favor, asegúrese que realmente desea borrar todas las transacciones de esta compañía. Sus datos maestros permanecerán intactos. Esta acción no se puede deshacer."
+Shopping Cart Settings,Compras Ajustes,
+Raw Material Cost,Costo de la Materia Prima,
+A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Existe una categoría de cliente con el mismo nombre, por favor cambie el nombre del cliente o cambie el nombre de la categoría"
+Quotation {0} is cancelled,Cotización {0} se cancela,
+Quality Inspection required for Item {0},Inspección de la calidad requerida para el articulo {0}
+What does it do?,¿Qué hace?
+Actual Time (in Hours),Tiempo actual (En horas)
+Make Sales Order,Hacer Orden de Venta,
+Doc Type,Tipo Doc.
+List a few of your customers. They could be organizations or individuals.,Enumere algunos de sus clientes. Pueden ser organizaciones o individuos.
+Ref Code,Código Referencia,
+Default Selling Cost Center,Centros de coste por defecto,
+Leave Block List Allowed,Lista de Bloqueo de Vacaciones Permitida,
+Report Date,Fecha del Informe,
+Purchase Invoice {0} is already submitted,Factura de Compra {0} ya existe,
+Currency and Price List,Divisa y Lista de precios,
+Current Assets,Activo Corriente,
+Re-Order Qty,Reordenar Cantidad,
+Days for which Holidays are blocked for this department.,Días para los que Días Feriados se bloquean para este departamento .
+Customer Details,Datos del Cliente,
+**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,**Año Fiscal** representa un 'Ejercicio Financiero'. Los asientos contables y otras transacciones importantes se registran contra **Año Fiscal**
+Actual Qty is mandatory,Cantidad actual es obligatoria,
+Stock Reconciliation,Reconciliación de Inventario,
+Score must be less than or equal to 5,Puntuación debe ser menor o igual a 5,
+On Previous Row Total,En la Anterior Fila Total,
+Serial No / Batch,N º de serie / lote,
+Supplier Quotation Item,Articulo de la Cotización del Proveedor,
+Brokerage,Brokerage,
+Opportunity From,Oportunidad De,
+Supplier Address,Dirección del proveedor,
+Expected Delivery Date,Fecha Esperada de Envio,
+Parent Item,Artículo Principal,
+Software Developer,Desarrollador de Software,
+Website Item Groups,Grupos de Artículos del Sitio Web,
+Marketing Expenses,Gastos de Comercialización,
+"Cannot declare as lost, because Quotation has been made.","No se puede declarar como perdido , porque la cotización ha sido hecha."
+New Leaves Allocated,Nuevas Vacaciones Asignadas,
+user@example.com,user@example.com,
+Source Warehouse,fuente de depósito,
+No contacts added yet.,No se han añadido contactos todavía,
+Root Type is mandatory,Tipo Root es obligatorio,
+Scheduled,Programado,
+Depends on Leave Without Pay,Depende de ausencia sin pago,
+Total Paid Amt,Total Pagado Amt,
+'Days Since Last Order' must be greater than or equal to zero,'Días desde el último pedido' debe ser mayor o igual a cero,
+For Warehouse,Por almacén,
+Purchase Order Items To Be Received,Productos de la Orden de Compra a ser Recibidos,
+Delivery Note Message,Mensaje de la Nota de Entrega,
+Raw Materials Supplied Cost,Coste materias primas suministradas,
+Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},linea No. {0}: El importe no puede ser mayor que el reembolso pendiente {1}. El importe pendiente es {2}
+Synced With Hub,Sincronizado con Hub,
+Cost Center with existing transactions can not be converted to ledger,Centro de Costos de las transacciones existentes no se puede convertir en el libro mayor,
+Please enter Item Code to get batch no,"Por favor, ingrese el código del producto para obtener el No. de lote"
+Series is mandatory,Serie es obligatorio,
+Item Shortage Report,Reportar carencia de producto,
+Rate at which Price list currency is converted to customer's base currency,Grado en el que la lista de precios en moneda se convierte en la moneda base del cliente,
+Sales Invoice No,Factura de Venta No,
+Don't send Employee Birthday Reminders,En enviar recordatorio de cumpleaños del empleado,
+Ordered Items To Be Delivered,Artículos pedidos para ser entregados,
+Point-of-Sale Profile,Perfiles del Punto de Venta POS,
+Price List must be applicable for Buying or Selling,la lista de precios debe ser aplicable para comprar o vender,
+Serial No,Números de Serie,
+Bank Reconciliation Statement,Extractos Bancarios,
+{0} is mandatory for Item {1},{0} es obligatorio para el producto {1}
+Copy From Item Group,Copiar de Grupo de Elementos,
+{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) no puede ser mayor que cantidad planificada ({2}) en la Orden de Producción {3}
+Date of Joining must be greater than Date of Birth,Fecha de acceso debe ser mayor que Fecha de Nacimiento,
+Settings for Buying Module,Ajustes para la compra de módulo,
+Sales Person Targets,Metas de Vendedor,
+Standard contract terms for Sales or Purchase.,Condiciones contractuales estándar para ventas y compras.
+Actual Qty (at source/target),Cantidad Actual (en origen/destino)
+Privilege Leave,Permiso con Privilegio,
+Stock User,Foto del usuario,
+On Previous Row Amount,En la Fila Anterior de Cantidad,
+Weightage (%),Coeficiente de ponderación (% )
+Creation Time,Momento de la creación,
+Default Source Warehouse,Origen predeterminado Almacén,
+Sales Taxes and Charges Template,Plantilla de Cargos e Impuestos sobre Ventas,
+Educational Qualification,Capacitación Académica,
+From Time,Desde fecha,
+Health Concerns,Preocupaciones de salud,
+Purchase Receipt Item,Recibo de Compra del Artículo,
+Name or Email is mandatory,Nombre o Email es obligatorio,
+Transactions can only be deleted by the creator of the Company,Las transacciones sólo pueden ser borrados por el creador de la Compañía,
+Parent Cost Center,Centro de Costo Principal,
+Loans and Advances (Assets),Préstamos y anticipos (Activos)
+Shipments,Los envíos,
+Please enter 'Is Subcontracted' as Yes or No,"Por favor, introduzca si 'Es Subcontratado' o no"
+Abbreviation already used for another company,La Abreviación ya está siendo utilizada para otra compañía,
+Purchase Order Item Supplied,Orden de Compra del Artículo Suministrado,
+Sales Order Required,Orden de Ventas Requerida,
+Required Date,Fecha Requerida,
+Allow Overtime,Permitir horas extras,
+Reference No is mandatory if you entered Reference Date,Referencia No es obligatorio si introdujo Fecha de Referencia,
+Pricing Rule,Reglas de Precios,
+View Task,Vista de tareas,
+`Freeze Stocks Older Than` should be smaller than %d days.,`Congelar Inventarios Anteriores a` debe ser menor que %d días .
+Purchase Order number required for Item {0},Número de la Orden de Compra se requiere para el elemento {0}
+Create rules to restrict transactions based on values.,Crear reglas para restringir las transacciones basadas en valores .
+Raw Material Item Code,Materia Prima Código del Artículo,
+Supplier Quotation,Cotizaciónes a Proveedores,
+Activity Cost exists for Employee {0} against Activity Type - {1},Existe un costo de actividad para el empleado {0} contra el tipo de actividad - {1}
+Set targets Item Group-wise for this Sales Person.,Establecer objetivos artículo grupo que tienen para este vendedor.
+Total Value Difference (Out - In),Diferencia  (Salidas - Entradas)
+BOM and Manufacturing Quantity are required,Se requiere la lista de materiales (LdM) y cantidad a fabricar.
+Product Bundle,Conjunto/Paquete de productos,
+Requested For,Solicitados para,
+{0} against Sales Invoice {1},{0} contra Factura de Ventas {1}
+Select Items,Seleccione Artículos,
+Row {0}: {1} {2} does not match with {3},Fila {0}: {1} {2} no coincide con {3}
+Quality Management,Gestión de la Calidad,
+Details of the operations carried out.,Los detalles de las operaciones realizadas.
+Quality Inspection Reading,Lectura de Inspección de Calidad,
+Net Amount (Company Currency),Importe neto (moneda de la compañía)
+Track this Sales Order against any Project,Seguir este de órdenes de venta en contra de cualquier proyecto,
+"Selling must be checked, if Applicable For is selected as {0}","Ventas debe ser seleccionado, si se selecciona Aplicable Para como {0}"
+Maintain Same Rate Throughout Sales Cycle,Mantener misma tasa durante todo el ciclo de ventas,
+Salary,Salario,
+Stock Liabilities,Inventario de Pasivos,
+Shipping Rule Label,Regla Etiqueta de envío,
+This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,Este artículo es una plantilla y no se puede utilizar en las transacciones. Atributos artículo se copiarán en las variantes menos que se establece 'No Copy'
+Target  Amount,Monto Objtetivo,
+S.O. No.,S.O. No.
+Sanctioned Amount,importe sancionado,
+"If the account is frozen, entries are allowed to restricted users.","Si la cuenta está congelada , las entradas se les permite a los usuarios restringidos."
+Sales Taxes and Charges,Los impuestos y cargos de venta,
+Warehouse {0} can not be deleted as quantity exists for Item {1},Almacén {0} no se puede eliminar mientras exista cantidad de artículo {1}
+Bank Account No.,Número de Cuenta Bancaria,
+Shipping Account,cuenta Envíos,
+Parent Item Group,Grupo Principal de Artículos,
+Warranty Period (Days),Período de garantía ( Días)
+Campaign Naming By,Nombramiento de la Campaña Por,
+Terms and Conditions Content,Términos y Condiciones Contenido,
+Serial No {0} does not belong to Warehouse {1},Número de orden {0} no pertenece al Almacén {1}
+Shopping Cart Shipping Rule,Compras Regla de envío,
+Make Payment Entry,Registrar pago,
+Scheduled Date,Fecha prevista,
+% Ordered,% Pedido,
+'Expected Start Date' can not be greater than 'Expected End Date',La 'Fecha de inicio estimada' no puede ser mayor que la 'Fecha de finalización estimada'
+UOM Conversion Detail,Detalle de Conversión de Unidad de Medida,
+"To filter based on Party, select Party Type first","Para filtrar en base a la fiesta, seleccione Partido Escriba primero"
+Contact Name,Nombre del Contacto,
+Quotation Lost Reason,Cotización Pérdida Razón,
+Monthly Distribution Percentages,Los porcentajes de distribución mensuales,
+Plan for maintenance visits.,Plan para las visitas de mantenimiento.
+SO Qty,SO Cantidad,
+Quotation Series,Serie Cotización,
+New Customer Revenue,Ingresos de nuevo cliente,
+"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Caracteres especiales excepto ""-"" ""."", ""#"", y ""/"" no permitido en el nombramiento de serie"
+Schedule,Horario,
+Invoiced Amount (Exculsive Tax),Cantidad facturada ( Impuesto exclusive )
+Material Requests {0} created,Solicitud de Material {0} creada,
+Has Variants,Tiene Variantes,
+Taxes and Charges Added (Company Currency),Impuestos y Cargos Añadidos (Moneda Local)
+Buyer of Goods and Services.,Compradores de Productos y Servicios.
+Stock Balance,Balance de Inventarios,
+Cost Center For Item with Item Code ',Centro de Costos para artículo con Código del artículo '
+Write Off Cost Center,Centro de costos de desajuste,
+Please contact to the user who have Sales Master Manager {0} role,"Por favor, póngase en contacto con el usuario con función de Gerente de Ventas {0}"
+Allow the following users to approve Leave Applications for block days.,Permitir a los usuarios siguientes aprobar Solicitudes de ausencia en bloques de días.
+Net Rate,Tasa neta,
+Reference Row #,Referencia Fila #
+Employee Internal Work History,Historial de Trabajo Interno del Empleado,
+Salary Mode,Modo de Salario,
+Please enter parent cost center,"Por favor, ingrese el centro de costos maestro"
+Against Doctype,Contra Doctype,
+{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: 'Centro de Costos' es obligatorio para el producto {2}
+The net weight of this package. (calculated automatically as sum of net weight of items),El peso neto de este paquete . ( calculados automáticamente como la suma del peso neto del material)
+Projected Qty,Cant. Proyectada,
+Moving Average Rate,Porcentaje de Promedio Movil,
+Account {0}: Parent account {1} does not exist,Cuenta {0}: Cuenta Padre {1} no existe,
+Net Total (Company Currency),Total neto (Moneda Local)
+Delivery Note {0} must not be submitted,Nota de Entrega {0} no debe estar presentada,
+Lead Details,Iniciativas,
+Serial #,Serial #
+Vehicle No,Vehículo No,
+Lower Income,Ingreso Bajo,
+Duplicate Serial No entered for Item {0},Duplicar Serie No existe para la partida {0}
+Delivered Amount,Cantidad Entregada,
+New Company,Nueva Empresa,
+Permanent Address Is,Dirección permanente es,
+Max: {0},Max: {0}
+{0} {1} has been modified. Please refresh.,{0} {1} ha sido modificado. Por favor actualizar.
+Item Tax,Impuesto del artículo,
+Item Prices,Precios de los Artículos,
+Balance must be,Balance debe ser,
+A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Terceros / proveedor / comisionista / afiliado / distribuidor que vende productos de empresas a cambio de una comisión.
+Try planning operations for X days in advance.,Trate de operaciones para la planificación de X días de antelación.
+Expected End Date can not be less than Expected Start Date,La fecha prevista de finalización no puede ser inferior a la fecha de inicio,
+Please mention Round Off Account in Company,"Por favor, indique la cuenta que utilizará para el redondeo--"
+Serial No {0} does not belong to Delivery Note {1},Número de orden {0} no pertenece a la nota de entrega {1}
+Target Qty,Cantidad Objetivo,
+"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Se menciona Peso, \n ¡Por favor indique ""Peso Unidad de Medida"" también"
+You can not change rate if BOM mentioned agianst any item,No se puede cambiar la tasa si hay una Solicitud de Materiales contra cualquier artículo,
+Accounts,Contabilidad,
+per hour,por horas,
+Set as Closed,Establecer como Cerrada,
+Work In Progress,Trabajos en Curso,
+Credit Controller,Credit Controller,
+Purchase Receipt Item Supplied,Recibo de Compra del Artículo Adquirido,
+All Sales Partner Contact,Todo Punto de Contacto de Venta,
+View Leads,Ver ofertas,
+Currency is required for Price List {0},Se requiere de divisas para Lista de precios {0}
+Date of Birth cannot be greater than today.,La fecha de creación no puede ser mayor a la fecha de hoy.
+Reports to,Informes al,
+Provisional Profit / Loss (Credit),Beneficio / Pérdida (Crédito) Provisional,
+Ref SQ,Ref SQ,
+Total (Company Currency),Total (Compañía moneda)
+% of materials delivered against this Sales Order,% de materiales entregados contra la orden de venta,
+Account Currency,Moneda de la Cuenta,
+Party Balance,Saldo de socio,
+Name of the Monthly Distribution,Nombre de la Distribución Mensual,
+Finished Item {0} must be entered for Manufacture type entry,El producto terminado {0} debe ser introducido para la fabricación,
+Status must be one of {0},Estado debe ser uno de {0}
+Leave Block List,Lista de Bloqueo de Vacaciones,
+Customer's Item Code,Código de artículo del Cliente,
+Item Tax Amount,Total de impuestos de los artículos,
+Maintenance Visit Purpose,Propósito de la Visita de Mantenimiento,
+No of Sent SMS,No. de SMS enviados,
+Stock Received But Not Billed,Inventario Recibido pero no facturados,
+Stores,Tiendas,
+Row {0}: Qty is mandatory,Fila {0}: Cantidad es obligatorio,
+Report Type is mandatory,Tipo de informe es obligatorio,
+"System User (login) ID. If set, it will become default for all HR forms.","Usuario del Sistema (login )ID. Si se establece , será por defecto para todas las formas de Recursos Humanos."
+UOM Conversion factor is required in row {0},"El factor de conversión de la (UdM) Unidad de medida, es requerida en la linea {0}"
+Electronics,Electrónica,
+Heads (or groups) against which Accounting Entries are made and balances are maintained.,Cuentas (o grupos) contra el que las entradas contables se hacen y los saldos se mantienen.
+If Income or Expense,Si es un ingreso o egreso,
+Row {0}: An Reorder entry already exists for this warehouse {1},Fila {0}: Una entrada para reordenar ya existe para este almacén {1}
+Lead,Iniciativas,
+There is not enough leave balance for Leave Type {0},No hay suficiente saldo para Tipo de Vacaciones {0}
+Repeat Customers,Repita los Clientes,
+Depreciation,Depreciación,
+Please create Customer from Lead {0},"Por favor, cree Cliente de la Oportunidad {0}"
+Make Sales Invoice,Hacer Factura de Venta,
+Supplier Invoice No,Factura del Proveedor No,
+Payment Account,Pago a cuenta,
+Cash Entry,Entrada de Efectivo,
+Select Fiscal Year...,Seleccione el año fiscal ...
+"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Para la fila {0} en {1}. e incluir {2} en la tasa del producto, las filas {3} también deben ser incluidas"
+Workstation is closed on the following dates as per Holiday List: {0},La estación de trabajo estará cerrada en las siguientes fechas según la lista de vacaciones: {0}
+Select company name first.,Seleccionar nombre de la empresa en primer lugar.
+With Items,Con artículos,
+Serial No {0} does not exist,Número de orden {0} no existe,
+Required By,Requerido por,
+Purchase Invoice Item,Factura de Compra del artículo,
+Quotation {0} not of type {1},Cotización {0} no es de tipo {1}
+Material Request {0} is cancelled or stopped,Solicitud de Material {0} cancelada o detenida,
+Supplied Items,Artículos suministrados,
+Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Los usuarios con esta función pueden establecer cuentas congeladas y crear / modificar los asientos contables contra las cuentas congeladas,
+Debit,Débito,
+"e.g. Bank, Cash, Credit Card","por ejemplo Banco, Efectivo , Tarjeta de crédito"
+Material Transferred for Manufacturing,Material transferido para fabricación,
+Item Reorder,Reordenar productos,
+Credit To account must be a Payable account,Crédito a la cuenta debe ser una cuenta por pagar,
+Lead Id,Iniciativa ID,
+Quotations received from Suppliers.,Cotizaciones recibidas de los proveedores.
+Sales Partner Target,Socio de Ventas Objetivo,
+Make Maintenance Visit,Hacer Visita de Mantenimiento,
+Stock cannot be updated against Delivery Note {0},Inventario no puede actualizarse contra Nota de Envio {0}
+Rent Cost,Renta Costo,
+Issues,Problemas,
+Current BOM,Lista de materiales actual,
+Row # {0}:,Fila # {0}:
+% Amount Billed,% Monto Facturado,
+Manage cost of operations,Administrar el costo de las operaciones,
+Company Email,Correo de la compañía,
+Single unit of an Item.,Números de serie únicos para cada producto,
+Delivery Notes {0} must be cancelled before cancelling this Sales Order,Nota de Entrega {0} debe ser cancelado antes de cancelar esta Orden Ventas,
+Tax Rate,Tasa de Impuesto,
+Utility Expenses,Los gastos de servicios públicos,
+Parent Account,Cuenta Primaria,
+Messages greater than 160 characters will be split into multiple messages,Los mensajes de más de 160 caracteres se dividirá en varios mensajes,
+{0}: {1} not found in Invoice Details table,{0}: {1} no se encuentra en el detalle de la factura,
+Leave blank if considered for all designations,Dejar en blanco si es considerada para todas las designaciones,
+Sales Register,Registros de Ventas,
+Account Head,Cuenta matriz,
+Single,solo,
+Send automatic emails to Contacts on Submitting transactions.,Enviar correos electrónicos automáticos a Contactos en transacciones SOMETER.
+{0} is not a valid Batch Number for Item {1},{0} no es un número de lote válido para el producto {1}
+"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","No se puede cambiar la moneda por defecto de la compañía, porque existen transacciones, estas deben ser canceladas para cambiar la moneda por defecto."
+Default BOM ({0}) must be active for this item or its template,La lista de materiales por defecto ({0}) debe estar activa para este producto o plantilla,
+Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Nota: Este centro de costos es un grupo. No se pueden crear asientos contables en los grupos.
+How frequently?,¿Con qué frecuencia ?
+Invoice No,Factura No,
+Bank A/C No.,Número de cuenta bancaria,
+Customer's Purchase Order No,Nº de Pedido de Compra del Cliente,
+Supplier Name,Nombre del Proveedor,
+Hour Rate,Hora de Cambio,
+Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Cantidad del punto obtenido después de la fabricación / reempaque de cantidades determinadas de materias primas,
+Get Outstanding Invoices,Verifique Facturas Pendientes,
+Shipping Address,Dirección de envío,
+"Settings for online shopping cart such as shipping rules, price list etc.","Ajustes para la compra online, como las normas de envío, lista de precios, etc."
+Series Updated,Series Actualizado,
+Contract End Date,Fecha Fin de Contrato,
+Attendance From Date,Asistencia De Fecha,
+Excise Entry,Entrada Impuestos Especiales,
+Appraisal Template Goal,Objetivo Plantilla de Evaluación,
+Opportunity,Oportunidades,
+Salary Slip,Planilla,
+Rate at which this tax is applied,Velocidad a la que se aplica este impuesto,
+Supplier Id,Proveedor Id,
+Block Holidays on important days.,Bloqueo de vacaciones en días importantes.
+Support Analtyics,Analitico de Soporte,
+Subcontract,Subcontrato,
+From Lead,De la iniciativa,
+Party,Socio,
+Update Cost,Actualización de Costos,
+Last Purchase Rate,Tasa de Cambio de la Última Compra,
+Actual Quantity,Cantidad actual,
+Stock Manager,Gerente,
+Shipping Rule Condition,Regla Condición inicial,
+Opening Balance Equity,Apertura de saldos de capital,
+Stock Entry Detail,Detalle de la Entrada de Inventario,
+'To Case No.' cannot be less than 'From Case No.','Hasta Caso No.' no puede ser inferior a 'Desde el Caso No.'
+Health Details,Detalles de la Salud,
+Unscheduled,No Programada,
+Other Details,Otros Datos,
+"Buying must be checked, if Applicable For is selected as {0}","Compra debe comprobarse, si se selecciona Aplicable Para como {0}"
+Period Closing Entry,Entradas de cierre de período,
+Cost of Purchased Items,El costo de artículos comprados,
+Delete Company Transactions,Eliminar Transacciones de la empresa,
+Stock UOM,Unidad de Media del Inventario,
+Itemwise Recommended Reorder Level,Nivel recomendado de re-ordenamiento de producto,
+Leave Type Name,Nombre de Tipo de Vacaciones,
+Actual End Time,Hora actual de finalización,
+Please mention Round Off Cost Center in Company,"Por favor, indique las centro de costos para el redondeo--"
+Under Graduate,Bajo Graduación,
+Purchase Receipt No,Recibo de Compra No,
+Default Buying Price List,Lista de precios predeterminada,
+Lead Time Date,Fecha y Hora de la Iniciativa,
+Maintenance start date can not be before delivery date for Serial No {0},Mantenimiento fecha de inicio no puede ser antes de la fecha de entrega para la Serie No {0}
+Suggestions,Sugerencias,
+Warehouse where you are maintaining stock of rejected items,Almacén en el que está manteniendo un balance de los artículos rechazados,
+Default Cost of Goods Sold Account,Cuenta de costos de venta por defecto,
+Is Carry Forward,Es llevar adelante,
+"Create and manage daily, weekly and monthly email digests.","Creación y gestión de resúmenes de correo electrónico diarias , semanales y mensuales."
+Sales Order to Payment,Órdenes de venta al Pago,
+Warning: Leave application contains following block dates,Advertencia: Solicitud de Renuncia contiene las siguientes fechas bloquedas,
+Total Leaves Allocated,Total Vacaciones Asignadas,
+Default settings for selling transactions.,Los ajustes por defecto para las transacciones de venta.
+Customize the Notification,Personalice la Notificación,
+Make Difference Entry,Hacer Entrada de Diferencia,
+Ordered Qty,Cantidad Pedida,
+Total(Amt),Total (Amt)
+Credit Card Entry,Introducción de tarjetas de crédito,
+Applicable To (Designation),Aplicables a (Denominación )
+Stock Options,Opciones sobre Acciones,
+Receivable,Cuenta por Cobrar,
+Opportunity From field is mandatory,El campo 'Oportunidad de' es obligatorio,
+-Above,-Mayor,
+Office Maintenance Expenses,Gastos de Mantenimiento de Oficinas,
+Manufacturing,Producción,
+'Entries' cannot be empty,'Entradas' no puede estar vacío,
+Leave Control Panel,Salir del Panel de Control,
+Percentage Allocation,Porcentaje de asignación de,
+Shipping Amount,Importe del envío,
+Item Code is mandatory because Item is not automatically numbered,El código del artículo es obligatorio porque el producto no se enumera automáticamente,
+Sales Order Item,Articulo de la Solicitud de Venta,
+Parent Sales Person,Contacto Principal de Ventas,
+Warehouse Contact Info,Información de Contacto del Almacén,
+Statutory info and other general information about your Supplier,Información legal y otra información general acerca de su proveedor,
+Unit of Measure {0} has been entered more than once in Conversion Factor Table,Unidad de Medida {0} se ha introducido más de una vez en la Tabla de Factores de Conversión,
+From Currency and To Currency cannot be same,'Desde Moneda' y 'A Moneda' no puede ser la misma,
+Default settings for Shopping Cart,Ajustes por defecto para Compras,
+Cost Center with existing transactions can not be converted to group,Centro de Costos de las transacciones existentes no se puede convertir al grupo,
+Year Start Date,Fecha de Inicio,
+Supplier Naming By,Ordenar proveedores por:
+Sales Invoice Message,Mensaje de la Factura,
+Notify by Email on creation of automatic Material Request,Notificarme por Email cuando se genere una nueva solicitud de materiales,
+"Specify the operations, operating cost and give a unique Operation no to your operations.","Especifique la operación , el costo de operación y dar una operación única que no a sus operaciones."
+Shopping Cart,Cesta de la compra,
+Supplier,Proveedores,
+Accounting Ledger,Libro Mayor Contable,
+Stop Birthday Reminders,Detener recordatorios de cumpleaños,
+Sales Expenses,Gastos de Ventas,
+Warranty / AMC Details,Garantía / AMC Detalles,
+No of Visits,No. de visitas,
+Leave Approver Name,Nombre de Supervisor de Vacaciones,
+Item Description,Descripción del Artículo,
+Cost of Issued Items,Costo de Artículos Emitidas,
+Stock Expenses,Inventario de Gastos,
+Lead Time Days,Tiempo de Entrega en Días,
+Tax Assets,Activos por Impuestos,
+Schedules,Horarios,
+Tax Amount After Discount Amount,Total de Impuestos Después Cantidad de Descuento,
+Has Serial No,Tiene No de Serie,
+Sales Order required for Item {0},Orden de Venta requerida para el punto {0}
+Out of AMC,Fuera de AMC,
+Apply / Approve Leaves,Aplicar / Aprobar Vacaciones,
+Select Terms and Conditions,Selecciona Términos y Condiciones,
+Delivery Note {0} is not submitted,Nota de Entrega {0} no está presentada,
+"Row {0}: To set {1} periodicity, difference between from and to date \
 						must be greater than or equal to {2}","Fila {0}: Para establecer {1} periodicidad, diferencia entre desde y hasta la fecha \
  debe ser mayor que o igual a {2}"
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +163,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Luego las reglas de precios son filtradas en base a Cliente, Categoría de cliente, Territorio, Proveedor, Tipo de Proveedor, Campaña, Socio de Ventas, etc"
-DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,Introduzca el nombre de la campaña si el origen de la encuesta es una campaña
-DocType: BOM Item,Scrap %,Chatarra %
-apps/erpnext/erpnext/public/js/setup_wizard.js +52,Upload your letter head and logo. (you can edit them later).,Carge su membrete y su logotipo. (Puede editarlos más tarde).
-DocType: Item,Is Purchase Item,Es una compra de productos
-DocType: Serial No,Delivery Document No,Entrega del documento No
-DocType: Notification Control,Notification Control,Control de Notificación
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +93,Administrative Officer,Oficial Administrativo
-DocType: BOM,Show In Website,Mostrar En Sitio Web
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +167,Bank Overdraft Account,Cuenta de sobregiros
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +586,Warning: Another {0} # {1} exists against stock entry {2},Existe otro {0} # {1} contra la entrada de población {2}: Advertencia
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +46,'Update Stock' can not be checked because items are not delivered via {0},'Actualizar Stock' no se puede marcar porque los productos no se entregan a través de {0}
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +64,Approval Status must be 'Approved' or 'Rejected',"Estado de aprobación debe ser "" Aprobado "" o "" Rechazado """
-DocType: Daily Work Summary Group,Holiday List,Lista de Feriados
-DocType: Selling Settings,Settings for Selling Module,Ajustes para vender Módulo
-apps/erpnext/erpnext/public/js/setup_wizard.js +118,"e.g. ""Build tools for builders""","por ejemplo "" Herramientas para los Constructores """
-DocType: Purchase Invoice,Taxes and Charges Deducted,Impuestos y Gastos Deducidos
-DocType: Work Order Operation,Actual Time and Cost,Tiempo y costo actual
-DocType: Additional Salary,HR User,Usuario Recursos Humanos
-DocType: Purchase Invoice,Unpaid,No pagado
-DocType: SMS Center,All Sales Person,Todos Ventas de Ventas
-apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,Requisición de materiales hacia la órden de compra
-apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Administrar Puntos de venta.
-DocType: Journal Entry,Opening Entry,Entrada de Apertura
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Ordenado
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Costo del Material que se adjunta
-DocType: Item,Default Unit of Measure,Unidad de Medida Predeterminada
-DocType: Purchase Invoice,Credit To,Crédito Para
-DocType: Currency Exchange,To Currency,Para la moneda
-apps/erpnext/erpnext/config/stock.py +194,Unit of Measure,Unidad de Medida
-DocType: Item,Material Issue,Incidencia de Material
-,Material Requests for which Supplier Quotations are not created,Solicitudes de Productos sin Cotizaciones Creadas
-DocType: Course Assessment Criteria,Weightage,Coeficiente de Ponderación
-DocType: Item,"Example: ABCD.#####
+"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Luego las reglas de precios son filtradas en base a Cliente, Categoría de cliente, Territorio, Proveedor, Tipo de Proveedor, Campaña, Socio de Ventas, etc"
+Enter name of campaign if source of enquiry is campaign,Introduzca el nombre de la campaña si el origen de la encuesta es una campaña,
+Scrap %,Chatarra %
+Upload your letter head and logo. (you can edit them later).,Carge su membrete y su logotipo. (Puede editarlos más tarde).
+Is Purchase Item,Es una compra de productos,
+Delivery Document No,Entrega del documento No,
+Notification Control,Control de Notificación,
+Administrative Officer,Oficial Administrativo,
+Show In Website,Mostrar En Sitio Web,
+Bank Overdraft Account,Cuenta de sobregiros,
+Warning: Another {0} # {1} exists against stock entry {2},Existe otro {0} # {1} contra la entrada de población {2}: Advertencia,
+'Update Stock' can not be checked because items are not delivered via {0},'Actualizar Stock' no se puede marcar porque los productos no se entregan a través de {0}
+Approval Status must be 'Approved' or 'Rejected',"Estado de aprobación debe ser "" Aprobado "" o "" Rechazado """
+Holiday List,Lista de Feriados,
+Settings for Selling Module,Ajustes para vender Módulo,
+"e.g. ""Build tools for builders""","por ejemplo "" Herramientas para los Constructores """
+Taxes and Charges Deducted,Impuestos y Gastos Deducidos,
+Actual Time and Cost,Tiempo y costo actual,
+HR User,Usuario Recursos Humanos,
+Unpaid,No pagado,
+All Sales Person,Todos Ventas de Ventas,
+Material Request to Purchase Order,Requisición de materiales hacia la órden de compra,
+Manage Sales Partners.,Administrar Puntos de venta.
+Opening Entry,Entrada de Apertura,
+Ordered,Ordenado,
+Cost of Delivered Items,Costo del Material que se adjunta,
+Default Unit of Measure,Unidad de Medida Predeterminada,
+Credit To,Crédito Para,
+To Currency,Para la moneda,
+Unit of Measure,Unidad de Medida,
+Material Issue,Incidencia de Material,
+Material Requests for which Supplier Quotations are not created,Solicitudes de Productos sin Cotizaciones Creadas,
+Weightage,Coeficiente de Ponderación,
+"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.","Ejemplo:. ABCD ##### 
  Si la serie se establece y Número de Serie no se menciona en las transacciones, entonces se creara un número de serie automático sobre la base de esta serie. Si siempre quiere mencionar explícitamente los números de serie para este artículo, déjelo en blanco."
-DocType: Purchase Receipt Item,Recd Quantity,Recd Cantidad
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,New Account Name,Nombre de nueva cuenta
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +148,Balance for Account {0} must always be {1},Balance de cuenta {0} debe ser siempre {1}
-DocType: Purchase Invoice,Supplier Warehouse,Almacén Proveedor
-apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Campañas de Ventas.
-DocType: Request for Quotation Item,Project Name,Nombre del proyecto
-,Serial No Warranty Expiry,Número de orden de caducidad Garantía
-DocType: Asset Repair,Manufacturing Manager,Gerente de Manufactura
-DocType: BOM,Item UOM,Unidad de Medida del Artículo
-apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +27,Total Invoiced Amt,Total Monto Facturado
-DocType: Leave Application,Total Leave Days,Total Vacaciones
-apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,Plantilla de Impuestos para las transacciones de venta.
-DocType: Appraisal Goal,Score Earned,Puntuación Obtenida
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +942,Re-open,Re Abrir
-DocType: Item Reorder,Material Request Type,Tipo de Solicitud de Material
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187,Serial No {0} not found,Serial No {0} no encontrado
-DocType: Quotation,Rate at which Price list currency is converted to company's base currency,Grado en el que la lista de precios en moneda se convierte en la moneda base de la compañía
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +167,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Fila {0}: cantidad asignada {1} debe ser menor o igual a cantidad pendiente a facturar {2}
-DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Monto de impuestos Después Cantidad de Descuento (Compañía moneda)
-DocType: Holiday List,Holiday List Name,Lista de nombres de vacaciones
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +909,Sales Return,Volver Ventas
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11,Automotive,Automotor
-DocType: Payment Schedule,Payment Amount,Pago recibido
-DocType: Purchase Order Item Supplied,Supplied Qty,Suministrado Cantidad
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +171,Employee cannot report to himself.,Empleado no puede informar a sí mismo.
-DocType: Stock Entry,Delivery Note No,No. de Nota de Entrega
-DocType: Journal Entry Account,Purchase Order,Órdenes de Compra
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +52,Employee {0} is not active or does not exist,Empleado {0} no está activo o no existe
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +639,POS Profile required to make POS Entry,Se requiere un perfil POS para crear entradas en el Punto-de-Venta
-,Requested Items To Be Ordered,Solicitud de Productos Aprobados
-DocType: Salary Slip,Leave Without Pay,Licencia sin Sueldo
-apps/erpnext/erpnext/accounts/doctype/account/account.py +88,Root cannot be edited.,Root no se puede editar .
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +250,Source warehouse is mandatory for row {0},Almacén de origen es obligatoria para la fila {0}
-DocType: Sales Partner,Target Distribution,Distribución Objetivo
-DocType: BOM,Item Image (if not slideshow),"Imagen del Artículo (si no, presentación de diapositivas)"
-DocType: Naming Series,Change the starting / current sequence number of an existing series.,Defina el número de secuencia nuevo para esta transacción
-DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Depósito sólo se puede cambiar a través de la Entrada de Almacén / Nota de Entrega / Recibo de Compra
-DocType: Quotation,Quotation To,Cotización Para
-apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30,Select Fiscal Year,Seleccione el año fiscal
-apps/erpnext/erpnext/stock/doctype/item/item.py +479,'Has Serial No' can not be 'Yes' for non-stock item,"'Tiene Número de Serie' no puede ser ""Sí"" para elementos que son de inventario"
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Efectivo Disponible
-DocType: Salary Component,Earning,Ganancia
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27,Please specify currency in Company,"Por favor, especifique la moneda en la compañía"
-DocType: Notification Control,Purchase Order Message,Mensaje de la Orden de Compra
-DocType: Customer Group,Only leaf nodes are allowed in transaction,Sólo las Cuentas de Detalle se permiten en una transacción
-apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,Fecha se repite
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +112,Government,Gobierno
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46,Securities & Commodity Exchanges,Valores y Bolsas de Productos
-DocType: Item,Items with higher weightage will be shown higher,Los productos con mayor peso se mostraran arriba
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +77,Both Warehouse must belong to same Company,Ambos almacenes deben pertenecer a una misma empresa
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +139,Row # {0}: Cannot return more than {1} for Item {2},Fila # {0}: No se puede devolver más de {1} para el artículo {2}
-DocType: Supplier,Supplier of Goods or Services.,Proveedor de Productos o Servicios.
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +91,Secretary,Secretario
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,Lead must be set if Opportunity is made from Lead,La Iniciativa se debe establecer si la oportunidad está hecha desde Iniciativas
-DocType: Work Order Operation,Operation completed for how many finished goods?,La operación se realizó para la cantidad de productos terminados?
-DocType: Rename Tool,Type of document to rename.,Tipo de documento para cambiar el nombre.
-DocType: Leave Type,Include holidays within leaves as leaves,"Incluir las vacaciones con ausencias, únicamente como ausencias"
-DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.",Asiento contable congelado actualmente ; nadie puede modificar el asiento  excepto el rol que se especifica a continuación .
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +160,Duties and Taxes,Derechos e Impuestos
-apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Árbol de la lista de materiales
-DocType: Asset Maintenance,Manufacturing User,Usuario de Manufactura
-,Profit and Loss Statement,Estado de Pérdidas y Ganancias
-DocType: Item Supplier,Item Supplier,Proveedor del Artículo
-apps/erpnext/erpnext/accounts/doctype/account/account.py +55,Account {0}: Parent account {1} can not be a ledger,Cuenta {0}: Cuenta Padre {1} no puede ser una cuenta Mayor
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,Asistencia Desde Fecha y Hasta Fecha de Asistencia es obligatoria
-apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25,Cart is Empty,El carro esta vacío
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,Primero la nota de entrega
-,Monthly Attendance Sheet,Hoja de Asistencia Mensual
-DocType: Upload Attendance,Get Template,Verificar Plantilla
-apps/erpnext/erpnext/controllers/accounts_controller.py +886,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included",Para incluir el impuesto de la linea {0} los impuestos de las lineas {1} también deben ser incluidos
-DocType: Sales Invoice Advance,Sales Invoice Advance,Factura Anticipadas
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129,Quantity for Item {0} must be less than {1},Cantidad de elemento {0} debe ser menor de {1}
-DocType: Stock Ledger Entry,Stock Value Difference,Diferencia de Valor de Inventario
-DocType: Material Request Item,Min Order Qty,Cantidad mínima de Pedido (MOQ)
-DocType: Item,Website Warehouse,Almacén del Sitio Web
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +275,Source and target warehouse cannot be same for row {0},Fuente y el almacén de destino no pueden ser la misma para la fila {0}
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +75,Submit Salary Slip,Presentar nómina
-DocType: Shipping Rule,Specify conditions to calculate shipping amount,Especificar condiciones de calcular el importe de envío
-apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,Este es una categoría de cliente raíz y no se puede editar.
-DocType: Item,Customer Items,Artículos de clientes
-DocType: Selling Settings,Customer Naming By,Naming Cliente Por
-DocType: Account,Fixed Asset,Activos Fijos
-DocType: Purchase Invoice,Start date of current invoice's period,Fecha del período de facturación actual Inicie
-DocType: Appraisal Goal,Score (0-5),Puntuación ( 0-5)
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","Para establecer este Año Fiscal como Predeterminado , haga clic en "" Establecer como Predeterminado """
-apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,¿Dónde se realizan las operaciones de fabricación.
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,Evaluación {0} creado por Empleado {1} en el rango de fechas determinado
-DocType: Employee Leave Approver,Employee Leave Approver,Supervisor de Vacaciones del Empleado
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33,Investment Banking,Banca de Inversión
-apps/erpnext/erpnext/utilities/user_progress.py +146,Unit,Unidad
-,Stock Analytics,Análisis de existencias
-DocType: Leave Control Panel,Leave blank if considered for all departments,Dejar en blanco si se considera para todos los departamentos
-,Purchase Order Items To Be Billed,Ordenes de Compra por Facturar
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +115,The selected item cannot have Batch,El elemento seleccionado no puede tener lotes
-DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Ajuste del tipo de cuenta le ayuda en la selección de esta cuenta en las transacciones.
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +166,User {0} is already assigned to Employee {1},El usuario {0} ya está asignado a Empleado {1}
-DocType: Account,Expenses Included In Valuation,Gastos dentro de la valoración
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Clientes Nuevos
-DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Total Impuestos y Cargos (Moneda Local)
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +81,Piecework,Pieza de trabajo
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +106,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,El elemento {0}: Con la cantidad ordenada {1} no puede ser menor que el pedido mínimo {2} (definido en el producto).
-DocType: Warehouse,A logical Warehouse against which stock entries are made.,Un almacén lógico por el cual se hacen las entradas de existencia.
-DocType: Item,Has Batch No,Tiene lote No
-DocType: Serial No,Creation Document Type,Tipo de creación de documentos
-DocType: Supplier Quotation Item,Prevdoc DocType,DocType Prevdoc
-DocType: Student Attendance Tool,Batch,Lotes de Producto
-DocType: BOM Update Tool,The BOM which will be replaced,La Solicitud de Materiales que será sustituida
-apps/erpnext/erpnext/accounts/doctype/account/account.py +105,Account with child nodes cannot be set as ledger,La Cuenta con subcuentas no puede convertirse en libro de diario.
-,Stock Projected Qty,Cantidad de Inventario Proyectada
-DocType: Work Order Operation,Updated via 'Time Log',Actualizado a través de 'Hora de Registro'
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +408,{0} against Bill {1} dated {2},{0} contra Factura {1} de fecha {2}
-apps/erpnext/erpnext/utilities/user_progress.py +138,Your Products or Services,Sus productos o servicios
-apps/erpnext/erpnext/controllers/accounts_controller.py +864,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} es obligatorio. Tal vez tipo de cambio no se ha creado para {1} en {2}.
-DocType: Cashier Closing,To Time,Para Tiempo
-apps/erpnext/erpnext/public/js/templates/address_list.html +20,No address added yet.,No se ha añadido ninguna dirección todavía.
-,Terretory,Territorios
-DocType: Naming Series,Series List for this Transaction,Lista de series para esta transacción
-DocType: Item Attribute Value,"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","Esto se añade al Código del Artículo de la variante. Por ejemplo, si su abreviatura es ""SM"", y el código del artículo es ""CAMISETA"", el código de artículo de la variante será ""CAMISETA-SM"""
-DocType: Workstation,Wages,Salario
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +197,Outstanding for {0} cannot be less than zero ({1}),Sobresaliente para {0} no puede ser menor que cero ({1} )
-DocType: Appraisal Goal,Appraisal Goal,Evaluación Meta
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Balance de Inventario en Lote {0} se convertirá en negativa {1} para la partida {2} en Almacén {3}
-DocType: Manufacturing Settings,Allow Production on Holidays,Permitir Producción en Vacaciones
-DocType: Purchase Invoice,Terms,Términos
-apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +50,Supplier(s),Proveedor (s)
-DocType: Serial No,Serial No Details,Serial No Detalles
-DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Permitir al usuario editar Precio de Lista  en las transacciones
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +286,Serial Nos Required for Serialized Item {0},Serie n Necesario para artículo serializado {0}
-DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Mostrar ""en la acción "" o "" No disponible "", basada en stock disponible en este almacén."
-DocType: Employee,Place of Issue,Lugar de emisión
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +263,Purchase Order {0} is not submitted,La órden de compra {0} no existe
-apps/erpnext/erpnext/controllers/accounts_controller.py +376,Account {0} is invalid. Account Currency must be {1},La Cuenta {0} no es válida. La Moneda de la Cuenta debe de ser {1}
-DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Si este artículo tiene variantes, entonces no podrá ser seleccionado en los pedidos de venta, etc."
-DocType: Sales Invoice,Sales Team1,Team1 Ventas
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +583,Stock Entry {0} is not submitted,Entrada de la {0} no se presenta
-apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Consultas de soporte de clientes .
-apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,Cotizaciones a Oportunidades o Clientes
-apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Consumed Amount,Cantidad Consumida
-apps/erpnext/erpnext/stock/doctype/item/item.py +507,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,"Campo de impuesto del producto {0} debe tener un tipo de cuenta de impuestos, ingresos, cargos o gastos"
-DocType: Purchase Order Item,Supplier Part Number,Número de pieza del proveedor
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date','Desde fecha' debe ser después de 'Hasta Fecha'
-apps/erpnext/erpnext/accounts/doctype/account/account.py +135,Account with child nodes cannot be converted to ledger,Cuenta con nodos hijos no se puede convertir a cuentas del libro mayor
-,Serial No Service Contract Expiry,Número de orden de servicio Contrato de caducidad
-apps/erpnext/erpnext/controllers/buying_controller.py +200,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Almacén de Proveedor es necesario para recibos de compras sub contratadas
-DocType: Employee Education,School/University,Escuela / Universidad
-apps/erpnext/erpnext/stock/get_item_details.py +167,Item {0} must be a Sub-contracted Item,El elemento {0} debe ser un producto sub-contratado
-DocType: Supplier,Is Frozen,Está Inactivo
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191,Serial No {0} is under warranty upto {1},Número de orden {0} está en garantía hasta {1}
-apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Configuración global para todos los procesos de fabricación.
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +204,Actual type tax cannot be included in Item rate in row {0},"El tipo de impuesto actual, no puede ser incluido en el precio del producto de la linea {0}"
-DocType: Stock Settings,Role Allowed to edit frozen stock,Función Permitida para editar Inventario Congelado
-DocType: Pricing Rule,"Higher the number, higher the priority","Mayor es el número, mayor es la prioridad"
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84,Stock cannot exist for Item {0} since has variants,Inventario no puede existir para el punto {0} ya tiene variantes
-DocType: Leave Control Panel,Carry Forward,Cargar
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +212,Account {0} is frozen,Cuenta {0} está congelada
-DocType: Asset Maintenance Log,Periodicity,Periodicidad
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +333,Raw Materials cannot be blank.,Materias primas no pueden estar en blanco.
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +135,Date Of Retirement must be greater than Date of Joining,Fecha de la jubilación debe ser mayor que Fecha de acceso
-,Employee Leave Balance,Balance de Vacaciones del Empleado
-DocType: Sales Person,Sales Person Name,Nombre del Vendedor
-DocType: Territory,Classification of Customers by region,Clasificación de los clientes por región
-DocType: Purchase Invoice,Grand Total (Company Currency),Suma total (Moneda Local)
-DocType: Purchase Invoice Item,Quantity and Rate,Cantidad y Cambio
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Can. en balance
-DocType: BOM,Materials Required (Exploded),Materiales necesarios ( despiece )
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +144,Source of Funds (Liabilities),Fuente de los fondos ( Pasivo )
-DocType: BOM,Exploded_items,Vista detallada
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +235,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Factura {0} debe ser cancelado antes de cancelar esta Orden Ventas
-DocType: GL Entry,Is Opening,Es apertura
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0} does not exist,Almacén {0} no existe
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +161,{0} is not a stock Item,{0} no es un producto de stock
-apps/erpnext/erpnext/controllers/accounts_controller.py +180,Due Date is mandatory,La fecha de vencimiento es obligatorio
-,Sales Person-wise Transaction Summary,Resumen de Transacción por Vendedor
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +92,Reorder Qty,Reordenar Cantidad
-DocType: BOM,Rate Of Materials Based On,Cambio de materiales basados en
-DocType: Landed Cost Voucher,Purchase Receipt Items,Artículos de Recibo de Compra
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Salir Cant.
-DocType: Sales Team,Contribution (%),Contribución (%)
-DocType: Cost Center,Cost Center Name,Nombre Centro de Costo
-DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Solicitud de Material utilizado para hacer esta Entrada de Inventario
-DocType: Fiscal Year,Year End Date,Año de Finalización
-DocType: Purchase Invoice,Supplier Invoice Date,Fecha de la Factura de Proveedor
-apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +71,This is a root item group and cannot be edited.,Se trata de un grupo de elementos raíz y no se puede editar .
-apps/erpnext/erpnext/controllers/buying_controller.py +719,Specified BOM {0} does not exist for Item {1},Solicitud de Materiales especificado {0} no existe la partida {1}
-apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Suma de puntos para todas las metas debe ser 100. Es {0}
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +323,There are more holidays than working days this month.,Hay más vacaciones que días de trabajo este mes.
-DocType: Packing Slip,Gross Weight UOM,Peso Bruto de la Unidad de Medida
-,Territory Target Variance Item Group-Wise,Variación de Grupo por Territorio Objetivo
-DocType: BOM,Item to be manufactured or repacked,Artículo a fabricar o embalados de nuevo
-DocType: Purchase Order,Supply Raw Materials,Suministro de Materias Primas
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +51,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Almacén no se puede suprimir porque hay una entrada en registro de inventario para este almacén.
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +39,Current BOM and New BOM can not be same,Solicitud de Materiales actual y Nueva Solicitud de Materiales no pueden ser iguales
-DocType: Account,Stock,Existencias
-apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py +75,Contribution %,Contribución %
-DocType: Stock Entry,Repack,Vuelva a embalar
-,Support Analytics,Analitico de Soporte
-DocType: Item,Average time taken by the supplier to deliver,Tiempo estimado por el proveedor para la recepción
-DocType: Pricing Rule,Apply On,Aplique En
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +400,{0} against Sales Order {1},{0} contra orden de venta {1}
-DocType: Work Order,Manufactured Qty,Cantidad Fabricada
-apps/erpnext/erpnext/config/manufacturing.py +38,Bill of Materials (BOM),Lista de Materiales (LdM)
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +27,General Ledger,Libro Mayor
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42,Serial No is mandatory for Item {0},No de serie es obligatoria para el elemento {0}
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Establecer como abierto
-apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Requerido Por
-apps/erpnext/erpnext/config/projects.py +36,Gantt chart of all tasks.,Diagrama de Gantt de todas las tareas .
-DocType: Purchase Order Item,Material Request Item,Elemento de la Solicitud de Material
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +57,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Solicitud de Materiales de máxima {0} se puede hacer para el punto {1} en contra de órdenes de venta {2}
-DocType: Delivery Note,Required only for sample item.,Sólo es necesario para el artículo de muestra .
-DocType: Email Digest,Add/Remove Recipients,Añadir / Quitar Destinatarios
-,Requested,Requerido
-DocType: Shipping Rule,Shipping Rule Conditions,Regla envío Condiciones
-apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py +87,Contribution Amount,Contribución Monto
-DocType: Work Order,Item To Manufacture,Artículo Para Fabricación
-DocType: Notification Control,Quotation Message,Cotización Mensaje
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock Assets,Activos de Inventario
-DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,Tasa a la cual la Moneda del Cliente se convierte a la moneda base del cliente
-apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Plantilla de impuestos para las transacciones de compra.
-DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Impuestos y Gastos Deducidos (Moneda Local)
-DocType: Stock Reconciliation Item,Stock Reconciliation Item,Articulo de Reconciliación de Inventario
-apps/erpnext/erpnext/accounts/doctype/account/account.py +57,Account {0}: Parent account {1} does not belong to company: {2},Cuenta {0}: Cuenta Padre {1} no pertenece a la compañía: {2}
-DocType: Serial No,Purchase / Manufacture Details,Detalles de Compra / Fábricas
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +440,Debit To account must be a Receivable account,La cuenta para Débito debe ser una cuenta por cobrar
-DocType: Warehouse,Warehouse Detail,Detalle de almacenes
-DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Enviar solicitud de materiales cuando se alcance un nivel bajo el stock
-DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Detalle de Calendario de Mantenimiento
-DocType: POS Item Group,Item Group,Grupo de artículos
-apps/erpnext/erpnext/config/selling.py +332,Point-of-Sale,Punto de venta
-DocType: Purchase Invoice Item,Rejected Serial No,Rechazado Serie No
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Asambleas Buscar Sub
-DocType: Item,Supplier Items,Artículos del Proveedor
-DocType: Opportunity,Contact Mobile No,No Móvil del Contacto
-DocType: Bank Statement Transaction Invoice Item,Invoice Date,Fecha de la factura
-DocType: Employee,Date Of Retirement,Fecha de la jubilación
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +218,Please set User ID field in an Employee record to set Employee Role,"Por favor, establece campo ID de usuario en un registro de empleado para establecer Función del Empleado"
-DocType: Products Settings,Home Page is Products,Pagína de Inicio es Productos
-DocType: Account,Round Off,Redondear
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +184,Set as Lost,Establecer como Perdidos
-,Sales Partners Commission,Comisiones de Ventas
-,Sales Person Target Variance Item Group-Wise,Variación por Vendedor de Meta
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +631,BOM {0} must be submitted,La lista de materiales (LdM) {0} debe ser enviada
-apps/erpnext/erpnext/controllers/buying_controller.py +204,Please select BOM in BOM field for Item {0},"Por favor, seleccione la Solicitud de Materiales en el campo de Solicitud de Materiales para el punto {0}"
-DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,Grado a la que la moneda de proveedor se convierte en la moneda base de la compañía
-DocType: Lead,Person Name,Nombre de la persona
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76,Batch number is mandatory for Item {0},Número de lote es obligatorio para el producto {0}
-apps/erpnext/erpnext/accounts/general_ledger.py +113,Account: {0} can only be updated via Stock Transactions,La cuenta: {0} sólo puede ser actualizada a través de transacciones de inventario
-DocType: Expense Claim,Employees Email Id,Empleados Email Id
-apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +81,Shortage Qty,Escasez Cantidad
-,Cash Flow,Flujo de Caja
-DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,Función que esta autorizada a presentar las transacciones que excedan los límites de crédito establecidos .
-apps/erpnext/erpnext/stock/utils.py +236,{0} valid serial nos for Item {1},{0} No. de serie válidos para el producto {1}
-DocType: Stock Settings,Default Stock UOM,Unidad de Medida Predeterminada para Inventario
-DocType: Job Opening,Description of a Job Opening,Descripción de una oferta de trabajo
-apps/erpnext/erpnext/controllers/trends.py +269,Project-wise data is not available for Quotation,El seguimiento preciso del proyecto no está disponible para la cotización--
-DocType: Company,Stock Settings,Ajustes de Inventarios
-DocType: Quotation Item,Quotation Item,Cotización del artículo
-DocType: Employee,Date of Issue,Fecha de emisión
-DocType: Sales Invoice Item,Sales Invoice Item,Articulo de la Factura de Venta
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +516,Customer {0} does not belong to project {1},Cliente {0} no pertenece a proyectar {1}
-DocType: Delivery Note Item,Against Sales Invoice Item,Contra la Factura de Venta de Artículos
-DocType: Sales Invoice,Accounting Details,detalles de la contabilidad
-apps/erpnext/erpnext/config/accounts.py +45,Accounting journal entries.,Entradas en el diario de contabilidad.
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +59,Missing Currency Exchange Rates for {0},Falta de Tipo de Cambio de moneda para {0}
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +173,Capital Stock,Capital Social
-DocType: HR Settings,Employee Records to be created by,Registros de empleados a ser creados por
-DocType: Account,Expense Account,Cuenta de gastos
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +246,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Programa de mantenimiento {0} debe ser cancelado antes de cancelar esta orden de venta
-DocType: Stock Ledger Entry,Actual Qty After Transaction,Cantidad actual después de la transacción
-apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,Cualquiera Cantidad Meta o Monto Meta es obligatoria
-DocType: Authorization Rule,Applicable To (Role),Aplicable a (Rol )
-DocType: Purchase Invoice Item,Amount (Company Currency),Importe (Moneda Local)
-apps/erpnext/erpnext/projects/doctype/project/project.js +54,Gantt Chart,Diagrama de Gantt
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +1103,Warning: Material Requested Qty is less than Minimum Order Qty,Advertencia: Cantidad de Material Solicitado es menor que Cantidad Mínima Establecida
-DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Planear bitácora de trabajo para las horas fuera de la estación.
-DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Aquí usted puede mantener la altura , el peso, alergias , problemas médicos , etc"
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +262,Against Journal Entry {0} does not have any unmatched {1} entry,Contra la Entrada de Diario {0} no tiene ninguna {1} entrada que vincular
-apps/erpnext/erpnext/controllers/buying_controller.py +405,Row #{0}: Rejected Qty can not be entered in Purchase Return,Fila # {0}: Rechazado Cantidad no se puede introducir en la Compra de Retorno
-apps/erpnext/erpnext/config/accounts.py +266,Enable / disable currencies.,Habilitar / Deshabilitar el tipo de monedas
-DocType: Stock Entry,Material Transfer for Manufacture,Trasferencia de Material para Manufactura
-apps/erpnext/erpnext/stock/doctype/item/item.py +583,"To merge, following properties must be same for both items","Para combinar, la siguientes propiedades deben ser las mismas para ambos artículos"
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195,Serial No {0} is under maintenance contract upto {1},Número de orden {0} tiene un contrato de mantenimiento hasta {1}
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83,Please pull items from Delivery Note,"Por favor, extraiga los productos desde la nota de entrega--"
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +1008,Fetch exploded BOM (including sub-assemblies),Mezclar Solicitud de Materiales (incluyendo subconjuntos )
-DocType: Stock Settings,Auto Material Request,Solicitud de Materiales Automatica
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +997,Get Items from BOM,Obtener elementos de la Solicitud de Materiales
-apps/erpnext/erpnext/config/selling.py +234,Customer Addresses And Contacts,Las direcciones de clientes y contactos
-apps/erpnext/erpnext/accounts/doctype/account/account.py +53,Account {0}: You can not assign itself as parent account,Cuenta {0}: no puede asignar la misma cuenta como su cuenta Padre.
-DocType: Item Price,Item Price,Precios de Productos
-DocType: Leave Control Panel,Leave blank if considered for all branches,Dejar en blanco si se considera para todas las ramas
-DocType: Purchase Order,To Bill,A Facturar
-DocType: Production Plan Sales Order,Production Plan Sales Order,Plan de producción de la orden de ventas (OV)
-DocType: Purchase Invoice,Return,Retorno
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +135,Please enter default currency in Company Master,"Por favor, ingrese la moneda por defecto en la compañía principal"
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +215,Middle Income,Ingresos Medio
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +280,Sales Invoice {0} has already been submitted,Factura {0} ya se ha presentado
-DocType: Employee Education,Year of Passing,Año de Fallecimiento
-DocType: Quotation,Rate at which customer's currency is converted to company's base currency,Tasa a la cual la Moneda del Cliente se convierte a la moneda base de la compañía
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +717,Manufacturing Quantity is mandatory,Cantidad de Fabricación es obligatoria
-DocType: Serial No,AMC Expiry Date,AMC Fecha de caducidad
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +137,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Fila {0}: el tipo de entidad se requiere para las cuentas por cobrar/pagar {1}
-DocType: Sales Invoice,Total Billing Amount,Monto total de facturación
-DocType: Branch,Branch,Rama
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40,Pension Funds,Fondos de Pensiones
-DocType: Shipping Rule,example: Next Day Shipping,ejemplo : Envío Día Siguiente
-DocType: Work Order,Actual Operating Cost,Costo de operación actual
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cannot convert Cost Center to ledger as it has child nodes,"No se puede convertir de 'Centros de Costos' a una cuenta del libro mayor, ya que tiene cuentas secundarias"
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +125,Telephone Expenses,Gastos por Servicios Telefónicos
-apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Porcentaje de asignación debe ser igual al 100 %
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +188,Against Journal Entry {0} is already adjusted against some other voucher,Contra la Entrada de Diario entrada {0} ya se ajusta contra algún otro comprobante
-DocType: Holiday,Holiday,Feriado
-DocType: Work Order Operation,Completed Qty,Cant. Completada
-DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,Pago neto (en palabras) será visible una vez que guarde la nómina.
-DocType: POS Profile,POS Profile,Perfiles POS
-apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Reglas para la adición de los gastos de envío .
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +200,Item Code required at Row No {0},Código del producto requerido en la fila No. {0}
-DocType: SMS Log,No of Requested SMS,No. de SMS solicitados
-apps/erpnext/erpnext/utilities/user_progress.py +146,Nos,Números
-DocType: Employee,Short biography for website and other publications.,Breve biografía de la página web y otras publicaciones.
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +257,Leave of type {0} cannot be longer than {1},Permiso de tipo {0} no puede tener más de {1}
-,Sales Browser,Navegador de Ventas
-DocType: Employee,Contact Details,Datos del Contacto
-apps/erpnext/erpnext/stock/utils.py +243,Warehouse {0} does not belong to company {1},Almacén {0} no pertenece a la empresa {1}
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,El artículo {0} no puede tener lotes
-DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,Los usuarios que pueden aprobar las solicitudes de licencia de un empleado específico
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +284,For Quantity (Manufactured Qty) is mandatory,Por Cantidad (Cantidad fabricada) es obligatorio
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +611,cannot be greater than 100,No puede ser mayor que 100
-DocType: Maintenance Visit,Customer Feedback,Comentarios del cliente
-DocType: Purchase Receipt Item Supplied,Required Qty,Cant. Necesaria
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +990,Delivery Note,Notas de Entrega
-DocType: Bin,Stock Value,Valor de Inventario
-DocType: Purchase Invoice,In Words (Company Currency),En palabras (Moneda Local)
-DocType: Website Item Group,Website Item Group,Grupo de Artículos del Sitio Web
-DocType: Item,Supply Raw Materials for Purchase,Materiales Suministro primas para la Compra
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +163,Series Updated Successfully,Serie actualizado correctamente
-DocType: Opportunity,Opportunity Date,Oportunidad Fecha
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7,There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,"Ha ocurrido un error . Una razón probable podría ser que usted no ha guardado el formulario. Por favor, póngase en contacto con support@erpnext.com si el problema persiste."
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +75,Max discount allowed for item: {0} is {1}%,Descuento máximo permitido para cada elemento: {0} es {1}%
-,POS,POS
-apps/erpnext/erpnext/hr/doctype/payroll_period/payroll_period.py +19,End Date can not be less than Start Date,Fecha Final no puede ser inferior a Fecha de Inicio
-DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,"Por favor seleccione trasladar, si usted desea incluir los saldos del año fiscal anterior a este año"
-DocType: Bank Account,Contact HTML,HTML del Contacto
-DocType: Shipping Rule,Calculate Based On,Calcular basado en
-DocType: Work Order,Qty To Manufacture,Cantidad Para Fabricación
-DocType: BOM Item,Basic Rate (Company Currency),Precio Base (Moneda Local)
-apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +50,Total Outstanding Amt,Monto Total Soprepasado
-apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Outstanding Amt,Monto Sobrepasado
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +231,Row {0}: Credit entry can not be linked with a {1},Fila {0}: Crédito no puede vincularse con {1}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133,Credit Card,Tarjeta de Crédito
-apps/erpnext/erpnext/accounts/party.py +288,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Partidas contables ya han sido realizadas en {0} para la empresa {1}. Por favor seleccione una cuenta por cobrar o pagar con moneda {0}
-apps/erpnext/erpnext/utilities/transaction_base.py +97,Duplicate row {0} with same {1},Duplicar fila {0} con el mismo {1}
-DocType: Leave Application,Leave Application,Solicitud de Vacaciones
-apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js +39,For Supplier,Por proveedor
-apps/erpnext/erpnext/config/maintenance.py +17,Visit report for maintenance call.,Informe de visita por llamada de mantenimiento .
-apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Vista en árbol para la administración de las categoría de vendedores
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +33,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,El numero de serie no tiene almacén. el almacén debe establecerse por entradas de stock o recibos de compra
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148,Overlapping conditions found between:,Condiciones coincidentes encontradas entre :
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49,Please specify a valid 'From Case No.',"Por favor, especifique 'Desde el caso No.' válido"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1064,Item or Warehouse for row {0} does not match Material Request,Artículo o Bodega para la fila {0} no coincide Solicitud de material
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +237,'Total','Total'
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Deudores
-DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Establecer presupuestos - Grupo sabio artículo en este Territorio. También puede incluir la estacionalidad mediante el establecimiento de la Distribución .
-DocType: Territory,For reference,Por referencia
-DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,Todas las transacciones de venta se pueden etiquetar contra múltiples **vendedores ** para que pueda establecer y monitorear metas.
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +49,Make Salary Slip,Hacer Nómina
-DocType: Purchase Invoice,Rounded Total (Company Currency),Total redondeado (Moneda local)
-DocType: Item,Default BOM,Solicitud de Materiales por Defecto
-,Delivery Note Trends,Tendencia de Notas de Entrega
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222,Serial No {0} has already been received,Número de orden {0} ya se ha recibido
-apps/erpnext/erpnext/stock/doctype/item/item.py +510,{0} entered twice in Item Tax,{0} ingresado dos veces en el Impuesto del producto
-apps/erpnext/erpnext/config/projects.py +13,Project master.,Proyecto maestro
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Sólo puede haber una Condición de Regla de Envió  con valor 0 o valor en blanco para ""To Value"""
-DocType: Item Group,Item Group Name,Nombre del grupo de artículos
-DocType: Purchase Taxes and Charges,On Net Total,En Total Neto
-DocType: Account,Root Type,Tipo Root
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +150,Reference No & Reference Date is required for {0},Se requiere de No de Referencia y Fecha de Referencia para {0}
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +151,Please enter relieving date.,"Por favor, introduzca la fecha de recepción."
-DocType: Sales Order Item,Gross Profit,Utilidad bruta
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +96,Warehouse not found in the system,Almacén no se encuentra en el sistema
-,Serial No Status,Número de orden Estado
-DocType: Blanket Order Item,Ordered Quantity,Cantidad Pedida
-DocType: Item,UOMs,Unidades de Medida
-DocType: Purchase Invoice Item,Price List Rate (Company Currency),Tarifa de la lista de precios (Moneda Local)
-DocType: Monthly Distribution,Distribution Name,Nombre del Distribución
-DocType: Journal Entry Account,Sales Order,Ordenes de Venta
-DocType: Purchase Invoice Item,Weight UOM,Peso Unidad de Medida
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +197,Work-in-Progress Warehouse is required before Submit,Se requiere un Almacen de Trabajo en Proceso antes de Enviar
-DocType: Production Plan,Get Sales Orders,Recibe Órdenes de Venta
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +203,Serial No {0} quantity {1} cannot be a fraction,Número de orden {0} {1} cantidad no puede ser una fracción
-DocType: Employee,Applicable Holiday List,Lista de Días Feriados Aplicable
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132,Successfully Reconciled,Reconciliado con éxito
-DocType: Payroll Entry,Select Employees,Seleccione Empleados
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Operaciones de Inventario antes de {0} se congelan
-DocType: Purchase Invoice Item,Net Rate (Company Currency),Tasa neta (Moneda Local)
-DocType: Period Closing Voucher,Closing Account Head,Cuenta de cierre principal
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72,Days Since Last Order,Días desde el último pedido
-DocType: Item Default,Default Buying Cost Center,Centro de Costos Por Defecto
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +257,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Visita de Mantenimiento {0} debe ser cancelado antes de cancelar la Orden de Ventas
-DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Adjuntar archivo .csv con dos columnas, una para el nombre antiguo y otro para el nombre nuevo"
-DocType: Depreciation Schedule,Schedule Date,Horario Fecha
-DocType: UOM,UOM Name,Nombre Unidad de Medida
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +256,Target warehouse is mandatory for row {0},Almacenes de destino es obligatorio para la fila {0}
-DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Obtener los elementos desde Recibos de Compra
-DocType: Item,Serial Number Series,Número de Serie Serie
-DocType: Sales Invoice,Product Bundle Help,Ayuda del conjunto/paquete de productos
-DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Especificar Tipo de Cambio para convertir una moneda en otra
+Recd Quantity,Recd Cantidad,
+New Account Name,Nombre de nueva cuenta,
+Balance for Account {0} must always be {1},Balance de cuenta {0} debe ser siempre {1}
+Supplier Warehouse,Almacén Proveedor,
+Sales campaigns.,Campañas de Ventas.
+Project Name,Nombre del proyecto,
+Serial No Warranty Expiry,Número de orden de caducidad Garantía,
+Manufacturing Manager,Gerente de Manufactura,
+Item UOM,Unidad de Medida del Artículo,
+Total Invoiced Amt,Total Monto Facturado,
+Total Leave Days,Total Vacaciones,
+Tax template for selling transactions.,Plantilla de Impuestos para las transacciones de venta.
+Score Earned,Puntuación Obtenida,
+Re-open,Re Abrir,
+Material Request Type,Tipo de Solicitud de Material,
+Serial No {0} not found,Serial No {0} no encontrado,
+Rate at which Price list currency is converted to company's base currency,Grado en el que la lista de precios en moneda se convierte en la moneda base de la compañía,
+Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Fila {0}: cantidad asignada {1} debe ser menor o igual a cantidad pendiente a facturar {2}
+Tax Amount After Discount Amount (Company Currency),Monto de impuestos Después Cantidad de Descuento (Compañía moneda)
+Holiday List Name,Lista de nombres de vacaciones,
+Sales Return,Volver Ventas,
+Automotive,Automotor,
+Payment Amount,Pago recibido,
+Supplied Qty,Suministrado Cantidad,
+Employee cannot report to himself.,Empleado no puede informar a sí mismo.
+Delivery Note No,No. de Nota de Entrega,
+Purchase Order,Órdenes de Compra,
+Employee {0} is not active or does not exist,Empleado {0} no está activo o no existe,
+POS Profile required to make POS Entry,Se requiere un perfil POS para crear entradas en el Punto-de-Venta,
+Requested Items To Be Ordered,Solicitud de Productos Aprobados,
+Leave Without Pay,Licencia sin Sueldo,
+Root cannot be edited.,Root no se puede editar .
+Source warehouse is mandatory for row {0},Almacén de origen es obligatoria para la fila {0}
+Target Distribution,Distribución Objetivo,
+Item Image (if not slideshow),"Imagen del Artículo (si no, presentación de diapositivas)"
+Change the starting / current sequence number of an existing series.,Defina el número de secuencia nuevo para esta transacción,
+Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Depósito sólo se puede cambiar a través de la Entrada de Almacén / Nota de Entrega / Recibo de Compra,
+Quotation To,Cotización Para,
+Select Fiscal Year,Seleccione el año fiscal,
+'Has Serial No' can not be 'Yes' for non-stock item,"'Tiene Número de Serie' no puede ser ""Sí"" para elementos que son de inventario"
+Cash In Hand,Efectivo Disponible,
+Earning,Ganancia,
+Please specify currency in Company,"Por favor, especifique la moneda en la compañía"
+Purchase Order Message,Mensaje de la Orden de Compra,
+Only leaf nodes are allowed in transaction,Sólo las Cuentas de Detalle se permiten en una transacción,
+Date is repeated,Fecha se repite,
+Government,Gobierno,
+Securities & Commodity Exchanges,Valores y Bolsas de Productos,
+Items with higher weightage will be shown higher,Los productos con mayor peso se mostraran arriba,
+Both Warehouse must belong to same Company,Ambos almacenes deben pertenecer a una misma empresa,
+Row # {0}: Cannot return more than {1} for Item {2},Fila # {0}: No se puede devolver más de {1} para el artículo {2}
+Supplier of Goods or Services.,Proveedor de Productos o Servicios.
+Secretary,Secretario,
+Lead must be set if Opportunity is made from Lead,La Iniciativa se debe establecer si la oportunidad está hecha desde Iniciativas,
+Operation completed for how many finished goods?,La operación se realizó para la cantidad de productos terminados?
+Type of document to rename.,Tipo de documento para cambiar el nombre.
+Include holidays within leaves as leaves,"Incluir las vacaciones con ausencias, únicamente como ausencias"
+"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.",Asiento contable congelado actualmente ; nadie puede modificar el asiento  excepto el rol que se especifica a continuación .
+Duties and Taxes,Derechos e Impuestos,
+Tree of Bill of Materials,Árbol de la lista de materiales,
+Manufacturing User,Usuario de Manufactura,
+Profit and Loss Statement,Estado de Pérdidas y Ganancias,
+Item Supplier,Proveedor del Artículo,
+Account {0}: Parent account {1} can not be a ledger,Cuenta {0}: Cuenta Padre {1} no puede ser una cuenta Mayor,
+Attendance From Date and Attendance To Date is mandatory,Asistencia Desde Fecha y Hasta Fecha de Asistencia es obligatoria,
+Cart is Empty,El carro esta vacío,
+Please Delivery Note first,Primero la nota de entrega,
+Monthly Attendance Sheet,Hoja de Asistencia Mensual,
+Get Template,Verificar Plantilla,
+"To include tax in row {0} in Item rate, taxes in rows {1} must also be included",Para incluir el impuesto de la linea {0} los impuestos de las lineas {1} también deben ser incluidos,
+Sales Invoice Advance,Factura Anticipadas,
+Quantity for Item {0} must be less than {1},Cantidad de elemento {0} debe ser menor de {1}
+Stock Value Difference,Diferencia de Valor de Inventario,
+Min Order Qty,Cantidad mínima de Pedido (MOQ)
+Website Warehouse,Almacén del Sitio Web,
+Source and target warehouse cannot be same for row {0},Fuente y el almacén de destino no pueden ser la misma para la fila {0}
+Submit Salary Slip,Presentar nómina,
+Specify conditions to calculate shipping amount,Especificar condiciones de calcular el importe de envío,
+This is a root customer group and cannot be edited.,Este es una categoría de cliente raíz y no se puede editar.
+Customer Items,Artículos de clientes,
+Customer Naming By,Naming Cliente Por,
+Fixed Asset,Activos Fijos,
+Start date of current invoice's period,Fecha del período de facturación actual Inicie,
+Score (0-5),Puntuación ( 0-5)
+"To set this Fiscal Year as Default, click on 'Set as Default'","Para establecer este Año Fiscal como Predeterminado , haga clic en "" Establecer como Predeterminado """
+Where manufacturing operations are carried.,¿Dónde se realizan las operaciones de fabricación.
+Appraisal {0} created for Employee {1} in the given date range,Evaluación {0} creado por Empleado {1} en el rango de fechas determinado,
+Employee Leave Approver,Supervisor de Vacaciones del Empleado,
+Investment Banking,Banca de Inversión,
+Unit,Unidad,
+Stock Analytics,Análisis de existencias,
+Leave blank if considered for all departments,Dejar en blanco si se considera para todos los departamentos,
+Purchase Order Items To Be Billed,Ordenes de Compra por Facturar,
+The selected item cannot have Batch,El elemento seleccionado no puede tener lotes,
+Setting Account Type helps in selecting this Account in transactions.,Ajuste del tipo de cuenta le ayuda en la selección de esta cuenta en las transacciones.
+User {0} is already assigned to Employee {1},El usuario {0} ya está asignado a Empleado {1}
+Expenses Included In Valuation,Gastos dentro de la valoración,
+New Customers,Clientes Nuevos,
+Total Taxes and Charges (Company Currency),Total Impuestos y Cargos (Moneda Local)
+Piecework,Pieza de trabajo,
+Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,El elemento {0}: Con la cantidad ordenada {1} no puede ser menor que el pedido mínimo {2} (definido en el producto).
+A logical Warehouse against which stock entries are made.,Un almacén lógico por el cual se hacen las entradas de existencia.
+Has Batch No,Tiene lote No,
+Creation Document Type,Tipo de creación de documentos,
+Prevdoc DocType,DocType Prevdoc,
+Batch,Lotes de Producto,
+The BOM which will be replaced,La Solicitud de Materiales que será sustituida,
+Account with child nodes cannot be set as ledger,La Cuenta con subcuentas no puede convertirse en libro de diario.
+Stock Projected Qty,Cantidad de Inventario Proyectada,
+Updated via 'Time Log',Actualizado a través de 'Hora de Registro'
+{0} against Bill {1} dated {2},{0} contra Factura {1} de fecha {2}
+Your Products or Services,Sus productos o servicios,
+{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} es obligatorio. Tal vez tipo de cambio no se ha creado para {1} en {2}.
+To Time,Para Tiempo,
+No address added yet.,No se ha añadido ninguna dirección todavía.
+Terretory,Territorios,
+Series List for this Transaction,Lista de series para esta transacción,
+"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","Esto se añade al Código del Artículo de la variante. Por ejemplo, si su abreviatura es ""SM"", y el código del artículo es ""CAMISETA"", el código de artículo de la variante será ""CAMISETA-SM"""
+Wages,Salario,
+Outstanding for {0} cannot be less than zero ({1}),Sobresaliente para {0} no puede ser menor que cero ({1} )
+Appraisal Goal,Evaluación Meta,
+Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Balance de Inventario en Lote {0} se convertirá en negativa {1} para la partida {2} en Almacén {3}
+Allow Production on Holidays,Permitir Producción en Vacaciones,
+Terms,Términos,
+Supplier(s),Proveedor (s)
+Serial No Details,Serial No Detalles,
+Allow user to edit Price List Rate in transactions,Permitir al usuario editar Precio de Lista  en las transacciones,
+Serial Nos Required for Serialized Item {0},Serie n Necesario para artículo serializado {0}
+"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Mostrar ""en la acción "" o "" No disponible "", basada en stock disponible en este almacén."
+Place of Issue,Lugar de emisión,
+Purchase Order {0} is not submitted,La órden de compra {0} no existe,
+Account {0} is invalid. Account Currency must be {1},La Cuenta {0} no es válida. La Moneda de la Cuenta debe de ser {1}
+"If this item has variants, then it cannot be selected in sales orders etc.","Si este artículo tiene variantes, entonces no podrá ser seleccionado en los pedidos de venta, etc."
+Sales Team1,Team1 Ventas,
+Stock Entry {0} is not submitted,Entrada de la {0} no se presenta,
+Support queries from customers.,Consultas de soporte de clientes .
+Quotes to Leads or Customers.,Cotizaciones a Oportunidades o Clientes,
+Consumed Amount,Cantidad Consumida,
+Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,"Campo de impuesto del producto {0} debe tener un tipo de cuenta de impuestos, ingresos, cargos o gastos"
+Supplier Part Number,Número de pieza del proveedor,
+'From Date' must be after 'To Date','Desde fecha' debe ser después de 'Hasta Fecha'
+Account with child nodes cannot be converted to ledger,Cuenta con nodos hijos no se puede convertir a cuentas del libro mayor,
+Serial No Service Contract Expiry,Número de orden de servicio Contrato de caducidad,
+Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Almacén de Proveedor es necesario para recibos de compras sub contratadas,
+School/University,Escuela / Universidad,
+Item {0} must be a Sub-contracted Item,El elemento {0} debe ser un producto sub-contratado,
+Is Frozen,Está Inactivo,
+Serial No {0} is under warranty upto {1},Número de orden {0} está en garantía hasta {1}
+Global settings for all manufacturing processes.,Configuración global para todos los procesos de fabricación.
+Actual type tax cannot be included in Item rate in row {0},"El tipo de impuesto actual, no puede ser incluido en el precio del producto de la linea {0}"
+Role Allowed to edit frozen stock,Función Permitida para editar Inventario Congelado,
+"Higher the number, higher the priority","Mayor es el número, mayor es la prioridad"
+Stock cannot exist for Item {0} since has variants,Inventario no puede existir para el punto {0} ya tiene variantes,
+Carry Forward,Cargar,
+Account {0} is frozen,Cuenta {0} está congelada,
+Periodicity,Periodicidad,
+Raw Materials cannot be blank.,Materias primas no pueden estar en blanco.
+Date Of Retirement must be greater than Date of Joining,Fecha de la jubilación debe ser mayor que Fecha de acceso,
+Employee Leave Balance,Balance de Vacaciones del Empleado,
+Sales Person Name,Nombre del Vendedor,
+Classification of Customers by region,Clasificación de los clientes por región,
+Grand Total (Company Currency),Suma total (Moneda Local)
+Quantity and Rate,Cantidad y Cambio,
+Balance Qty,Can. en balance,
+Materials Required (Exploded),Materiales necesarios ( despiece )
+Source of Funds (Liabilities),Fuente de los fondos ( Pasivo )
+Exploded_items,Vista detallada,
+Sales Invoice {0} must be cancelled before cancelling this Sales Order,Factura {0} debe ser cancelado antes de cancelar esta Orden Ventas,
+Is Opening,Es apertura,
+Warehouse {0} does not exist,Almacén {0} no existe,
+{0} is not a stock Item,{0} no es un producto de stock,
+Due Date is mandatory,La fecha de vencimiento es obligatorio,
+Sales Person-wise Transaction Summary,Resumen de Transacción por Vendedor,
+Reorder Qty,Reordenar Cantidad,
+Rate Of Materials Based On,Cambio de materiales basados en,
+Purchase Receipt Items,Artículos de Recibo de Compra,
+Out Qty,Salir Cant.
+Contribution (%),Contribución (%)
+Cost Center Name,Nombre Centro de Costo,
+Material Request used to make this Stock Entry,Solicitud de Material utilizado para hacer esta Entrada de Inventario,
+Year End Date,Año de Finalización,
+Supplier Invoice Date,Fecha de la Factura de Proveedor,
+This is a root item group and cannot be edited.,Se trata de un grupo de elementos raíz y no se puede editar .
+Specified BOM {0} does not exist for Item {1},Solicitud de Materiales especificado {0} no existe la partida {1}
+Sum of points for all goals should be 100. It is {0},Suma de puntos para todas las metas debe ser 100. Es {0}
+There are more holidays than working days this month.,Hay más vacaciones que días de trabajo este mes.
+Gross Weight UOM,Peso Bruto de la Unidad de Medida,
+Territory Target Variance Item Group-Wise,Variación de Grupo por Territorio Objetivo,
+Item to be manufactured or repacked,Artículo a fabricar o embalados de nuevo,
+Supply Raw Materials,Suministro de Materias Primas,
+Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Almacén no se puede suprimir porque hay una entrada en registro de inventario para este almacén.
+Current BOM and New BOM can not be same,Solicitud de Materiales actual y Nueva Solicitud de Materiales no pueden ser iguales,
+Stock,Existencias,
+Contribution %,Contribución %
+Repack,Vuelva a embalar,
+Support Analytics,Analitico de Soporte,
+Average time taken by the supplier to deliver,Tiempo estimado por el proveedor para la recepción,
+Apply On,Aplique En,
+{0} against Sales Order {1},{0} contra orden de venta {1}
+Manufactured Qty,Cantidad Fabricada,
+Bill of Materials (BOM),Lista de Materiales (LdM)
+General Ledger,Libro Mayor,
+Serial No is mandatory for Item {0},No de serie es obligatoria para el elemento {0}
+Set as Open,Establecer como abierto,
+Required On,Requerido Por,
+Gantt chart of all tasks.,Diagrama de Gantt de todas las tareas .
+Material Request Item,Elemento de la Solicitud de Material,
+Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Solicitud de Materiales de máxima {0} se puede hacer para el punto {1} en contra de órdenes de venta {2}
+Required only for sample item.,Sólo es necesario para el artículo de muestra .
+Add/Remove Recipients,Añadir / Quitar Destinatarios,
+Requested,Requerido,
+Shipping Rule Conditions,Regla envío Condiciones,
+Contribution Amount,Contribución Monto,
+Item To Manufacture,Artículo Para Fabricación,
+Quotation Message,Cotización Mensaje,
+Stock Assets,Activos de Inventario,
+Rate at which Customer Currency is converted to customer's base currency,Tasa a la cual la Moneda del Cliente se convierte a la moneda base del cliente,
+Tax template for buying transactions.,Plantilla de impuestos para las transacciones de compra.
+Taxes and Charges Deducted (Company Currency),Impuestos y Gastos Deducidos (Moneda Local)
+Stock Reconciliation Item,Articulo de Reconciliación de Inventario,
+Account {0}: Parent account {1} does not belong to company: {2},Cuenta {0}: Cuenta Padre {1} no pertenece a la compañía: {2}
+Purchase / Manufacture Details,Detalles de Compra / Fábricas,
+Debit To account must be a Receivable account,La cuenta para Débito debe ser una cuenta por cobrar,
+Warehouse Detail,Detalle de almacenes,
+Raise Material Request when stock reaches re-order level,Enviar solicitud de materiales cuando se alcance un nivel bajo el stock,
+Maintenance Schedule Detail,Detalle de Calendario de Mantenimiento,
+Item Group,Grupo de artículos,
+Point-of-Sale,Punto de venta,
+Rejected Serial No,Rechazado Serie No,
+Search Sub Assemblies,Asambleas Buscar Sub,
+Supplier Items,Artículos del Proveedor,
+Contact Mobile No,No Móvil del Contacto,
+Invoice Date,Fecha de la factura,
+Date Of Retirement,Fecha de la jubilación,
+Please set User ID field in an Employee record to set Employee Role,"Por favor, establece campo ID de usuario en un registro de empleado para establecer Función del Empleado"
+Home Page is Products,Pagína de Inicio es Productos,
+Round Off,Redondear,
+Set as Lost,Establecer como Perdidos,
+Sales Partners Commission,Comisiones de Ventas,
+Sales Person Target Variance Item Group-Wise,Variación por Vendedor de Meta,
+BOM {0} must be submitted,La lista de materiales (LdM) {0} debe ser enviada,
+Please select BOM in BOM field for Item {0},"Por favor, seleccione la Solicitud de Materiales en el campo de Solicitud de Materiales para el punto {0}"
+Rate at which supplier's currency is converted to company's base currency,Grado a la que la moneda de proveedor se convierte en la moneda base de la compañía,
+Person Name,Nombre de la persona,
+Batch number is mandatory for Item {0},Número de lote es obligatorio para el producto {0}
+Account: {0} can only be updated via Stock Transactions,La cuenta: {0} sólo puede ser actualizada a través de transacciones de inventario,
+Employees Email Id,Empleados Email Id,
+Shortage Qty,Escasez Cantidad,
+Cash Flow,Flujo de Caja,
+Role that is allowed to submit transactions that exceed credit limits set.,Función que esta autorizada a presentar las transacciones que excedan los límites de crédito establecidos .
+{0} valid serial nos for Item {1},{0} No. de serie válidos para el producto {1}
+Default Stock UOM,Unidad de Medida Predeterminada para Inventario,
+Description of a Job Opening,Descripción de una oferta de trabajo,
+Project-wise data is not available for Quotation,El seguimiento preciso del proyecto no está disponible para la cotización--
+Stock Settings,Ajustes de Inventarios,
+Quotation Item,Cotización del artículo,
+Date of Issue,Fecha de emisión,
+Sales Invoice Item,Articulo de la Factura de Venta,
+Customer {0} does not belong to project {1},Cliente {0} no pertenece a proyectar {1}
+Against Sales Invoice Item,Contra la Factura de Venta de Artículos,
+Accounting Details,detalles de la contabilidad,
+Accounting journal entries.,Entradas en el diario de contabilidad.
+Missing Currency Exchange Rates for {0},Falta de Tipo de Cambio de moneda para {0}
+Capital Stock,Capital Social,
+Employee Records to be created by,Registros de empleados a ser creados por,
+Expense Account,Cuenta de gastos,
+Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Programa de mantenimiento {0} debe ser cancelado antes de cancelar esta orden de venta,
+Actual Qty After Transaction,Cantidad actual después de la transacción,
+Either target qty or target amount is mandatory,Cualquiera Cantidad Meta o Monto Meta es obligatoria,
+Applicable To (Role),Aplicable a (Rol )
+Amount (Company Currency),Importe (Moneda Local)
+Gantt Chart,Diagrama de Gantt,
+Warning: Material Requested Qty is less than Minimum Order Qty,Advertencia: Cantidad de Material Solicitado es menor que Cantidad Mínima Establecida,
+Plan time logs outside Workstation Working Hours.,Planear bitácora de trabajo para las horas fuera de la estación.
+"Here you can maintain height, weight, allergies, medical concerns etc","Aquí usted puede mantener la altura , el peso, alergias , problemas médicos , etc"
+Against Journal Entry {0} does not have any unmatched {1} entry,Contra la Entrada de Diario {0} no tiene ninguna {1} entrada que vincular,
+Row #{0}: Rejected Qty can not be entered in Purchase Return,Fila # {0}: Rechazado Cantidad no se puede introducir en la Compra de Retorno,
+Enable / disable currencies.,Habilitar / Deshabilitar el tipo de monedas,
+Material Transfer for Manufacture,Trasferencia de Material para Manufactura,
+"To merge, following properties must be same for both items","Para combinar, la siguientes propiedades deben ser las mismas para ambos artículos"
+Serial No {0} is under maintenance contract upto {1},Número de orden {0} tiene un contrato de mantenimiento hasta {1}
+Please pull items from Delivery Note,"Por favor, extraiga los productos desde la nota de entrega--"
+Fetch exploded BOM (including sub-assemblies),Mezclar Solicitud de Materiales (incluyendo subconjuntos )
+Auto Material Request,Solicitud de Materiales Automatica,
+Get Items from BOM,Obtener elementos de la Solicitud de Materiales,
+Customer Addresses And Contacts,Las direcciones de clientes y contactos,
+Account {0}: You can not assign itself as parent account,Cuenta {0}: no puede asignar la misma cuenta como su cuenta Padre.
+Item Price,Precios de Productos,
+Leave blank if considered for all branches,Dejar en blanco si se considera para todas las ramas,
+To Bill,A Facturar,
+Production Plan Sales Order,Plan de producción de la orden de ventas (OV)
+Return,Retorno,
+Please enter default currency in Company Master,"Por favor, ingrese la moneda por defecto en la compañía principal"
+Middle Income,Ingresos Medio,
+Sales Invoice {0} has already been submitted,Factura {0} ya se ha presentado,
+Year of Passing,Año de Fallecimiento,
+Rate at which customer's currency is converted to company's base currency,Tasa a la cual la Moneda del Cliente se convierte a la moneda base de la compañía,
+Manufacturing Quantity is mandatory,Cantidad de Fabricación es obligatoria,
+AMC Expiry Date,AMC Fecha de caducidad,
+Row {0}: Party Type and Party is required for Receivable / Payable account {1},Fila {0}: el tipo de entidad se requiere para las cuentas por cobrar/pagar {1}
+Total Billing Amount,Monto total de facturación,
+Branch,Rama,
+Pension Funds,Fondos de Pensiones,
+example: Next Day Shipping,ejemplo : Envío Día Siguiente,
+Actual Operating Cost,Costo de operación actual,
+Cannot convert Cost Center to ledger as it has child nodes,"No se puede convertir de 'Centros de Costos' a una cuenta del libro mayor, ya que tiene cuentas secundarias"
+Telephone Expenses,Gastos por Servicios Telefónicos,
+Percentage Allocation should be equal to 100%,Porcentaje de asignación debe ser igual al 100 %
+Against Journal Entry {0} is already adjusted against some other voucher,Contra la Entrada de Diario entrada {0} ya se ajusta contra algún otro comprobante,
+Holiday,Feriado,
+Completed Qty,Cant. Completada,
+Net Pay (in words) will be visible once you save the Salary Slip.,Pago neto (en palabras) será visible una vez que guarde la nómina.
+POS Profile,Perfiles POS,
+Rules for adding shipping costs.,Reglas para la adición de los gastos de envío .
+Item Code required at Row No {0},Código del producto requerido en la fila No. {0}
+No of Requested SMS,No. de SMS solicitados,
+Nos,Números,
+Short biography for website and other publications.,Breve biografía de la página web y otras publicaciones.
+Leave of type {0} cannot be longer than {1},Permiso de tipo {0} no puede tener más de {1}
+Sales Browser,Navegador de Ventas,
+Contact Details,Datos del Contacto,
+Warehouse {0} does not belong to company {1},Almacén {0} no pertenece a la empresa {1}
+The Item {0} cannot have Batch,El artículo {0} no puede tener lotes,
+Users who can approve a specific employee's leave applications,Los usuarios que pueden aprobar las solicitudes de licencia de un empleado específico,
+For Quantity (Manufactured Qty) is mandatory,Por Cantidad (Cantidad fabricada) es obligatorio,
+cannot be greater than 100,No puede ser mayor que 100,
+Customer Feedback,Comentarios del cliente,
+Required Qty,Cant. Necesaria,
+Delivery Note,Notas de Entrega,
+Stock Value,Valor de Inventario,
+In Words (Company Currency),En palabras (Moneda Local)
+Website Item Group,Grupo de Artículos del Sitio Web,
+Supply Raw Materials for Purchase,Materiales Suministro primas para la Compra,
+Series Updated Successfully,Serie actualizado correctamente,
+Opportunity Date,Oportunidad Fecha,
+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.,"Ha ocurrido un error . Una razón probable podría ser que usted no ha guardado el formulario. Por favor, póngase en contacto con support@erpnext.com si el problema persiste."
+Max discount allowed for item: {0} is {1}%,Descuento máximo permitido para cada elemento: {0} es {1}%
+POS,POS,
+End Date can not be less than Start Date,Fecha Final no puede ser inferior a Fecha de Inicio,
+Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,"Por favor seleccione trasladar, si usted desea incluir los saldos del año fiscal anterior a este año"
+Contact HTML,HTML del Contacto,
+Calculate Based On,Calcular basado en,
+Qty To Manufacture,Cantidad Para Fabricación,
+Basic Rate (Company Currency),Precio Base (Moneda Local)
+Total Outstanding Amt,Monto Total Soprepasado,
+Outstanding Amt,Monto Sobrepasado,
+Row {0}: Credit entry can not be linked with a {1},Fila {0}: Crédito no puede vincularse con {1}
+Credit Card,Tarjeta de Crédito,
+Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Partidas contables ya han sido realizadas en {0} para la empresa {1}. Por favor seleccione una cuenta por cobrar o pagar con moneda {0}
+Duplicate row {0} with same {1},Duplicar fila {0} con el mismo {1}
+Leave Application,Solicitud de Vacaciones,
+For Supplier,Por proveedor,
+Visit report for maintenance call.,Informe de visita por llamada de mantenimiento .
+Manage Sales Person Tree.,Vista en árbol para la administración de las categoría de vendedores,
+New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,El numero de serie no tiene almacén. el almacén debe establecerse por entradas de stock o recibos de compra,
+Overlapping conditions found between:,Condiciones coincidentes encontradas entre :
+Please specify a valid 'From Case No.',"Por favor, especifique 'Desde el caso No.' válido"
+Item or Warehouse for row {0} does not match Material Request,Artículo o Bodega para la fila {0} no coincide Solicitud de material,
+'Total','Total'
+Debtors,Deudores,
+Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Establecer presupuestos - Grupo sabio artículo en este Territorio. También puede incluir la estacionalidad mediante el establecimiento de la Distribución .
+For reference,Por referencia,
+All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,Todas las transacciones de venta se pueden etiquetar contra múltiples **vendedores ** para que pueda establecer y monitorear metas.
+Make Salary Slip,Hacer Nómina,
+Rounded Total (Company Currency),Total redondeado (Moneda local)
+Default BOM,Solicitud de Materiales por Defecto,
+Delivery Note Trends,Tendencia de Notas de Entrega,
+Serial No {0} has already been received,Número de orden {0} ya se ha recibido,
+{0} entered twice in Item Tax,{0} ingresado dos veces en el Impuesto del producto,
+Project master.,Proyecto maestro,
+"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Sólo puede haber una Condición de Regla de Envió  con valor 0 o valor en blanco para ""To Value"""
+Item Group Name,Nombre del grupo de artículos,
+On Net Total,En Total Neto,
+Root Type,Tipo Root,
+Reference No & Reference Date is required for {0},Se requiere de No de Referencia y Fecha de Referencia para {0}
+Please enter relieving date.,"Por favor, introduzca la fecha de recepción."
+Gross Profit,Utilidad bruta,
+Warehouse not found in the system,Almacén no se encuentra en el sistema,
+Serial No Status,Número de orden Estado,
+Ordered Quantity,Cantidad Pedida,
+UOMs,Unidades de Medida,
+Price List Rate (Company Currency),Tarifa de la lista de precios (Moneda Local)
+Distribution Name,Nombre del Distribución,
+Sales Order,Ordenes de Venta,
+Weight UOM,Peso Unidad de Medida,
+Work-in-Progress Warehouse is required before Submit,Se requiere un Almacen de Trabajo en Proceso antes de Enviar,
+Get Sales Orders,Recibe Órdenes de Venta,
+Serial No {0} quantity {1} cannot be a fraction,Número de orden {0} {1} cantidad no puede ser una fracción,
+Applicable Holiday List,Lista de Días Feriados Aplicable,
+Successfully Reconciled,Reconciliado con éxito,
+Select Employees,Seleccione Empleados,
+Stock transactions before {0} are frozen,Operaciones de Inventario antes de {0} se congelan,
+Net Rate (Company Currency),Tasa neta (Moneda Local)
+Closing Account Head,Cuenta de cierre principal,
+Days Since Last Order,Días desde el último pedido,
+Default Buying Cost Center,Centro de Costos Por Defecto,
+Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Visita de Mantenimiento {0} debe ser cancelado antes de cancelar la Orden de Ventas,
+"Attach .csv file with two columns, one for the old name and one for the new name","Adjuntar archivo .csv con dos columnas, una para el nombre antiguo y otro para el nombre nuevo"
+Schedule Date,Horario Fecha,
+UOM Name,Nombre Unidad de Medida,
+Target warehouse is mandatory for row {0},Almacenes de destino es obligatorio para la fila {0}
+Get Items From Purchase Receipts,Obtener los elementos desde Recibos de Compra,
+Serial Number Series,Número de Serie Serie,
+Product Bundle Help,Ayuda del conjunto/paquete de productos,
+Specify Exchange Rate to convert one currency into another,Especificar Tipo de Cambio para convertir una moneda en otra,
diff --git a/erpnext/translations/fr-CA.csv b/erpnext/translations/fr-CA.csv
index 59283ee..0e3ca1f 100644
--- a/erpnext/translations/fr-CA.csv
+++ b/erpnext/translations/fr-CA.csv
@@ -1,14 +1,14 @@
-DocType: Production Plan Item,Ordered Qty,Quantité commandée
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +112,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Le Centre de Coûts {2} ne fait pas partie de la Société {3}
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Soit un montant au débit ou crédit est nécessaire pour {2}
-DocType: Purchase Invoice Item,Price List Rate (Company Currency),Taux de la Liste de Prix (Devise de la Compagnie)
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},{0} {1}: Client est requis envers un compte à recevoir {2}
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +126,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: L'entrée comptable pour {2} ne peut être faite qu'en devise: {3}
-DocType: Purchase Invoice Item,Price List Rate,Taux de la Liste de Prix
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Fournisseur est requis envers un compte à payer {2}
-DocType: Stock Settings,Auto insert Price List rate if missing,Insertion automatique du taux à la Liste de Prix si manquant
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +97,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Le compte {2} ne fait pas partie de la Société {3}
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +79,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: Le compte {2} de type 'Profit et Perte' n'est pas admis dans une Entrée d'Ouverture
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +93,{0} {1}: Account {2} is inactive,{0} {1}: Le compte {2} est inactif
-DocType: Journal Entry,Difference (Dr - Cr),Différence (Dt - Ct )
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +89,{0} {1}: Account {2} cannot be a Group,{0} {1}: Le compte {2} ne peut pas être un Groupe
+Ordered Qty,Quantité commandée,
+{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Le Centre de Coûts {2} ne fait pas partie de la Société {3}
+{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Soit un montant au débit ou crédit est nécessaire pour {2}
+Price List Rate (Company Currency),Taux de la Liste de Prix (Devise de la Compagnie)
+{0} {1}: Customer is required against Receivable account {2},{0} {1}: Client est requis envers un compte à recevoir {2}
+{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: L'entrée comptable pour {2} ne peut être faite qu'en devise: {3}
+Price List Rate,Taux de la Liste de Prix,
+{0} {1}: Supplier is required against Payable account {2},{0} {1}: Fournisseur est requis envers un compte à payer {2}
+Auto insert Price List rate if missing,Insertion automatique du taux à la Liste de Prix si manquant,
+{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Le compte {2} ne fait pas partie de la Société {3}
+{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: Le compte {2} de type 'Profit et Perte' n'est pas admis dans une Entrée d'Ouverture,
+{0} {1}: Account {2} is inactive,{0} {1}: Le compte {2} est inactif,
+Difference (Dr - Cr),Différence (Dt - Ct )
+{0} {1}: Account {2} cannot be a Group,{0} {1}: Le compte {2} ne peut pas être un Groupe,
diff --git a/erpnext/translations/fr.csv b/erpnext/translations/fr.csv
index ab9bf7d..0f6c309 100644
--- a/erpnext/translations/fr.csv
+++ b/erpnext/translations/fr.csv
@@ -951,7 +951,7 @@
 Ends On date cannot be before Next Contact Date.,La date de fin ne peut pas être avant la prochaine date de contact,
 Energy,Énergie,
 Engineer,Ingénieur,
-Enough Parts to Build,Pièces Suffisantes pour Construire
+Enough Parts to Build,Pièces Suffisantes pour Construire,
 Enroll,Inscrire,
 Enrolling student,Inscrire un étudiant,
 Enrolling students,Inscription des étudiants,
@@ -3037,7 +3037,7 @@
 To Date should be within the Fiscal Year. Assuming To Date = {0},La Date Finale doit être dans l'exercice. En supposant Date Finale = {0},
 To Datetime,À la Date,
 To Deliver,À Livrer,
-{}  To Deliver,{} à livrer
+{}  To Deliver,{} à livrer,
 To Deliver and Bill,À Livrer et Facturer,
 To Fiscal Year,À l'année fiscale,
 To GSTIN,GSTIN (Destination),
@@ -4943,8 +4943,8 @@
 Max Qty,Qté Max,
 Min Amt,Montant Min,
 Max Amt,Montant Max,
-"If rate is zero them item will be treated as ""Free Item""",Si le prix est à 0 alors l'article sera traité comme article gratuit
-Is Recursive,Est récursif
+"If rate is zero them item will be treated as ""Free Item""",Si le prix est à 0 alors l'article sera traité comme article gratuit,
+Is Recursive,Est récursif,
 "Discounts to be applied in sequential ranges like buy 1 get 1, buy 2 get 2, buy 3 get 3 and so on","La remise sera appliquée séquentiellement telque : acheter 1 => recupérer 1, acheter 2 => recupérer 2, acheter 3 => recupérer 3, etc..."
 Period Settings,Paramètres de période,
 Margin,Marge,
@@ -7240,7 +7240,7 @@
 Update latest price in all BOMs,Mettre à jour le prix le plus récent dans toutes les nomenclatures,
 BOM Website Item,Article de nomenclature du Site Internet,
 BOM Website Operation,Opération de nomenclature du Site Internet,
-Operation Time,Durée de l'Opération
+Operation Time,Durée de l'Opération,
 PO-JOB.#####,PO-JOB. #####,
 Timing Detail,Détail du timing,
 Time Logs,Time Logs,
@@ -9834,92 +9834,92 @@
 Creating Purchase Order ...,Création d'une commande d'achat ...,
 "Select a Supplier from the Default Suppliers of the items below. On selection, a Purchase Order will be made against items belonging to the selected Supplier only.","Sélectionnez un fournisseur parmi les fournisseurs par défaut des articles ci-dessous. Lors de la sélection, une commande d'achat sera effectué contre des articles appartenant uniquement au fournisseur sélectionné.",
 Row #{}: You must select {} serial numbers for item {}.,Ligne n ° {}: vous devez sélectionner {} numéros de série pour l'article {}.,
-Update Rate as per Last Purchase,Mettre à jour avec les derniers prix d'achats
-Company Shipping Address,Adresse d'expédition
-Shipping Address Details,Détail d'adresse d'expédition
-Company Billing Address,Adresse de la société de facturation
+Update Rate as per Last Purchase,Mettre à jour avec les derniers prix d'achats,
+Company Shipping Address,Adresse d'expédition,
+Shipping Address Details,Détail d'adresse d'expédition,
+Company Billing Address,Adresse de la société de facturation,
 Supplier Address Details,
-Bank Reconciliation Tool,Outil de réconcialiation d'écritures bancaires
-Supplier Contact,Contact fournisseur
-Subcontracting,Sous traitance
-Order Status,Statut de la commande
-Build,Personnalisations avancées
-Dispatch Address Name,Adresse de livraison intermédiaire
-Amount Eligible for Commission,Montant éligible à comission
-Grant Commission,Eligible aux commissions
-Stock Transactions Settings, Paramétre des transactions
-Role Allowed to Over Deliver/Receive, Rôle autorisé à dépasser cette limite
-Users with this role are allowed to over deliver/receive against orders above the allowance percentage,Rôle Utilisateur qui sont autorisé à livrée/commandé au-delà de la limite
-Over Transfer Allowance,Autorisation de limite de transfert
-Quality Inspection Settings,Paramétre de l'inspection qualité
-Action If Quality Inspection Is Rejected,Action si l'inspection qualité est rejetée
-Disable Serial No And Batch Selector,Désactiver le sélecteur de numéro de lot/série
-Is Rate Adjustment Entry (Debit Note),Est un justement du prix de la note de débit
-Issue a debit note with 0 qty against an existing Sales Invoice,Creer une note de débit avec une quatité à O pour la facture
-Control Historical Stock Transactions,Controle de l'historique des stransaction de stock
+Bank Reconciliation Tool,Outil de réconcialiation d'écritures bancaires,
+Supplier Contact,Contact fournisseur,
+Subcontracting,Sous traitance,
+Order Status,Statut de la commande,
+Build,Personnalisations avancées,
+Dispatch Address Name,Adresse de livraison intermédiaire,
+Amount Eligible for Commission,Montant éligible à comission,
+Grant Commission,Eligible aux commissions,
+Stock Transactions Settings, Paramétre des transactions,
+Role Allowed to Over Deliver/Receive, Rôle autorisé à dépasser cette limite,
+Users with this role are allowed to over deliver/receive against orders above the allowance percentage,Rôle Utilisateur qui sont autorisé à livrée/commandé au-delà de la limite,
+Over Transfer Allowance,Autorisation de limite de transfert,
+Quality Inspection Settings,Paramétre de l'inspection qualits,
+Action If Quality Inspection Is Rejected,Action si l'inspection qualité est rejetée,
+Disable Serial No And Batch Selector,Désactiver le sélecteur de numéro de lot/série,
+Is Rate Adjustment Entry (Debit Note),Est un justement du prix de la note de débit,
+Issue a debit note with 0 qty against an existing Sales Invoice,Creer une note de débit avec une quatité à O pour la facture,
+Control Historical Stock Transactions,Controle de l'historique des stransaction de stock,
 No stock transactions can be created or modified before this date.,Aucune transaction ne peux être créée ou modifié avant cette date.
-Stock transactions that are older than the mentioned days cannot be modified.,Les transactions de stock plus ancienne que le nombre de jours ci-dessus ne peuvent être modifiées
-Role Allowed to Create/Edit Back-dated Transactions,Rôle autorisé à créer et modifier des transactions anti-datée
+Stock transactions that are older than the mentioned days cannot be modified.,Les transactions de stock plus ancienne que le nombre de jours ci-dessus ne peuvent être modifiées,
+Role Allowed to Create/Edit Back-dated Transactions,Rôle autorisé à créer et modifier des transactions anti-datée,
 "If mentioned, the system will allow only the users with this Role to create or modify any stock transaction earlier than the latest stock transaction for a specific item and warehouse. If set as blank, it allows all users to create/edit back-dated transactions.","Les utilisateur de ce role pourront creer et modifier des transactions dans le passé. Si vide tout les utilisateurs pourrons le faire"
-Auto Insert Item Price If Missing,Création du prix de l'article dans les listes de prix si abscent
-Update Existing Price List Rate,Mise a jour automatique du prix dans les listes de prix
-Show Barcode Field in Stock Transactions,Afficher le champ Code Barre dans les transactions de stock
-Convert Item Description to Clean HTML in Transactions,Convertir les descriptions d'articles en HTML valide lors des transactions
-Have Default Naming Series for Batch ID?,Nom de série par défaut pour les Lots ou Séries
+Auto Insert Item Price If Missing,Création du prix de l'article dans les listes de prix si abscent,
+Update Existing Price List Rate,Mise a jour automatique du prix dans les listes de prix,
+Show Barcode Field in Stock Transactions,Afficher le champ Code Barre dans les transactions de stock,
+Convert Item Description to Clean HTML in Transactions,Convertir les descriptions d'articles en HTML valide lors des transactions,
+Have Default Naming Series for Batch ID?,Nom de série par défaut pour les Lots ou Séries,
 "The percentage you are allowed to transfer more against the quantity ordered. For example, if you have ordered 100 units, and your Allowance is 10%, then you are allowed transfer 110 units","Le pourcentage de quantité que vous pourrez réceptionner en plus de la quantité commandée. Par exemple, vous avez commandé 100 unités, votre pourcentage de dépassement est de 10%, vous pourrez réceptionner 110 unités"
-Allowed Items,Articles autorisés
-Party Specific Item,Restriction d'article disponible
-Restrict Items Based On,Type de critére de restriction
-Based On Value,critére de restriction
+Allowed Items,Articles autorisés,
+Party Specific Item,Restriction d'article disponible,
+Restrict Items Based On,Type de critére de restriction,
+Based On Value,critére de restriction,
 Unit of Measure (UOM),Unité de mesure (UdM),
 Unit Of Measure (UOM),Unité de mesure (UdM),
-CRM Settings,Paramètres CRM
-Do Not Explode,Ne pas décomposer
-Quick Access, Accés rapides
-{}  Available,{} Disponible.s
-{} Pending,{} En attente.s
-{} To Bill,{} à facturer
-{}  To Receive,{} A recevoir
+CRM Settings,Paramètres CRM,
+Do Not Explode,Ne pas décomposer,
+Quick Access, Accés rapides,
+{}  Available,{} Disponible.s,
+{} Pending,{} En attente.s,
+{} To Bill,{} à facturer,
+{}  To Receive,{} A recevoir,
 {} Active,{} Actif.ve(s)
 {} Open,{} Ouvert.e(s)
-Incorrect Data Report,Rapport de données incohérentes
-Incorrect Serial No Valuation,Valorisation inccorecte par Num. Série / Lots
-Incorrect Balance Qty After Transaction,Equilibre des quantités aprés une transaction
-Interview Type,Type d'entretien
-Interview Round,Cycle d'entretien
-Interview,Entretien
-Interview Feedback,Retour d'entretien
-Journal Energy Point,Historique des points d'énergies
+Incorrect Data Report,Rapport de données incohérentes,
+Incorrect Serial No Valuation,Valorisation inccorecte par Num. Série / Lots,
+Incorrect Balance Qty After Transaction,Equilibre des quantités aprés une transaction,
+Interview Type,Type d'entretien,
+Interview Round,Cycle d'entretien,
+Interview,Entretien,
+Interview Feedback,Retour d'entretien,
+Journal Energy Point,Historique des points d'énergies,
 Billing Address Details,Adresse de facturation (détails)
 Supplier Address Details,Adresse Fournisseur (détails)
-Retail,Commerce
-Users,Utilisateurs
-Permission Manager,Gestion des permissions
-Fetch Timesheet,Récuprer les temps saisis
-Get Supplier Group Details,Appliquer les informations depuis le Groupe de fournisseur
-Quality Inspection(s),Inspection(s) Qualité
-Set Advances and Allocate (FIFO),Affecter les encours au réglement
-Apply Putaway Rule,Appliquer la régle de routage d'entrepot
-Delete Transactions,Supprimer les transactions
-Default Payment Discount Account,Compte par défaut des paiements de remise
-Unrealized Profit / Loss Account,Compte de perte
-Enable Provisional Accounting For Non Stock Items,Activer la provision pour les articles non stockés
-Publish in Website,Publier sur le Site Web
-List View,Vue en liste
-Allow Excess Material Transfer,Autoriser les transfert de stock supérieurs à l'attendue
-Allow transferring raw materials even after the Required Quantity is fulfilled,Autoriser les transfert  de matiéres premiére mais si la quantité requise est atteinte
-Add Corrective Operation Cost in Finished Good Valuation,Ajouter des opérations de correction de coût pour la valorisation des produits finis
-Make Serial No / Batch from Work Order,Générer des numéros de séries / lots depuis les Ordres de Fabrications
-System will automatically create the serial numbers / batch for the Finished Good on submission of work order,le systéme va créer des numéros de séries / lots à la validation des produit finis depuis les Ordres de Fabrications
-Allow material consumptions without immediately manufacturing finished goods against a Work Order,Autoriser la consommation sans immédiatement fabriqué les produit fini dans les ordres de fabrication
-Quality Inspection Parameter,Paramétre des Inspection Qualité
-Parameter Group,Groupe de paramétre
-E Commerce Settings,Paramétrage E-Commerce
-Follow these steps to create a landing page for your store:,Suivez les intructions suivantes pour créer votre page d'accueil de boutique en ligne
-Show Price in Quotation,Afficher les prix sur les devis
-Add-ons,Extensions
-Enable Wishlist,Activer la liste de souhaits
-Enable Reviews and Ratings,Activer les avis et notes
-Enable Recommendations,Activer les recommendations
-Item Search Settings,Paramétrage de la recherche d'article
-Purchase demande,Demande de materiel
+Retail,Commerce,
+Users,Utilisateurs,
+Permission Manager,Gestion des permissions,
+Fetch Timesheet,Récuprer les temps saisis,
+Get Supplier Group Details,Appliquer les informations depuis le Groupe de fournisseur,
+Quality Inspection(s),Inspection(s) Qualite,
+Set Advances and Allocate (FIFO),Affecter les encours au réglement,
+Apply Putaway Rule,Appliquer la régle de routage d'entrepot,
+Delete Transactions,Supprimer les transactions,
+Default Payment Discount Account,Compte par défaut des paiements de remise,
+Unrealized Profit / Loss Account,Compte de perte,
+Enable Provisional Accounting For Non Stock Items,Activer la provision pour les articles non stockés,
+Publish in Website,Publier sur le Site Web,
+List View,Vue en liste,
+Allow Excess Material Transfer,Autoriser les transfert de stock supérieurs à l'attendue,
+Allow transferring raw materials even after the Required Quantity is fulfilled,Autoriser les transfert  de matiéres premiére mais si la quantité requise est atteinte,
+Add Corrective Operation Cost in Finished Good Valuation,Ajouter des opérations de correction de coût pour la valorisation des produits finis,
+Make Serial No / Batch from Work Order,Générer des numéros de séries / lots depuis les Ordres de Fabrications,
+System will automatically create the serial numbers / batch for the Finished Good on submission of work order,le systéme va créer des numéros de séries / lots à la validation des produit finis depuis les Ordres de Fabrications,
+Allow material consumptions without immediately manufacturing finished goods against a Work Order,Autoriser la consommation sans immédiatement fabriqué les produit fini dans les ordres de fabrication,
+Quality Inspection Parameter,Paramétre des Inspection Qualite,
+Parameter Group,Groupe de paramétre,
+E Commerce Settings,Paramétrage E-Commerce,
+Follow these steps to create a landing page for your store:,Suivez les intructions suivantes pour créer votre page d'accueil de boutique en ligne,
+Show Price in Quotation,Afficher les prix sur les devis,
+Add-ons,Extensions,
+Enable Wishlist,Activer la liste de souhaits,
+Enable Reviews and Ratings,Activer les avis et notes,
+Enable Recommendations,Activer les recommendations,
+Item Search Settings,Paramétrage de la recherche d'article,
+Purchase demande,Demande de materiel,
diff --git a/erpnext/translations/pl.csv b/erpnext/translations/pl.csv
index 4a93d49..4563b64 100644
--- a/erpnext/translations/pl.csv
+++ b/erpnext/translations/pl.csv
@@ -1,9839 +1,9745 @@
-"""Customer Provided Item"" cannot be Purchase Item also","""Element dostarczony przez klienta"" nie może być również elementem nabycia",
-"""Customer Provided Item"" cannot have Valuation Rate","""Element dostarczony przez klienta"" nie może mieć wskaźnika wyceny",
-"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","""Jest Środkiem Trwałym"" nie może być odznaczone, jeśli istnieją pozycje z takim ustawieniem",
-'Based On' and 'Group By' can not be same,"Pola ""Bazuje na"" i ""Grupuj wg."" nie mogą być takie same",
-'Days Since Last Order' must be greater than or equal to zero,Pole 'Dni od ostatniego zamówienia' musi być większe bądź równe zero,
-'Entries' cannot be empty,Pole 'Wpisy' nie może być puste,
-'From Date' is required,Pole 'Od daty' jest wymagane,
-'From Date' must be after 'To Date',Pole 'Od daty' musi następować później niż 'Do daty',
-'Has Serial No' can not be 'Yes' for non-stock item,Numer seryjny nie jest dostępny dla pozycji niemagazynowych,
-'Opening',&quot;Otwarcie&quot;,
-'To Case No.' cannot be less than 'From Case No.','To Case No.' nie powinno być mniejsze niż 'From Case No.',
-'To Date' is required,'Do daty' jest wymaganym polem,
-'Total',&#39;Całkowity&#39;,
-'Update Stock' can not be checked because items are not delivered via {0},"'Aktualizuj Stan' nie może być zaznaczone, ponieważ elementy nie są dostarczane przez {0}",
-'Update Stock' cannot be checked for fixed asset sale,Opcja 'Aktualizuj Stan' nie może być zaznaczona dla sprzedaży środka trwałego,
-) for {0},) dla {0},
-1 exact match.,1 dokładny mecz.,
-90-Above,90-Ponad,
-A Customer Group exists with same name please change the Customer name or rename the Customer Group,Grupa Odbiorców posiada taką nazwę - wprowadź inną nazwę Odbiorcy lub zmień nazwę Grupy,
-A Default Service Level Agreement already exists.,Domyślna umowa dotycząca poziomu usług już istnieje.,
-A Lead requires either a person's name or an organization's name,Ołów wymaga nazwy osoby lub nazwy organizacji,
-A customer with the same name already exists,Klient o tej samej nazwie już istnieje,
-A question must have more than one options,Pytanie musi mieć więcej niż jedną opcję,
-A qustion must have at least one correct options,Qustion musi mieć co najmniej jedną poprawną opcję,
-A {0} exists between {1} and {2} (,{0} istnieje pomiędzy {1} a {2} (,
-A4,A4,
-API Endpoint,Punkt końcowy API,
-API Key,Klucz API,
-Abbr can not be blank or space,Skrót nie może być pusty lub być spacją,
-Abbreviation already used for another company,Skrót już używany przez inną firmę,
-Abbreviation cannot have more than 5 characters,Skrót nie może posiadać więcej niż 5 znaków,
-Abbreviation is mandatory,Skrót jest obowiązkowy,
-About the Company,O firmie,
-About your company,O Twojej firmie,
-Above,Powyżej,
-Absent,Nieobecny,
-Academic Term,semestr,
-Academic Term: ,Okres akademicki:,
-Academic Year,Rok akademicki,
-Academic Year: ,Rok akademicki:,
-Accepted + Rejected Qty must be equal to Received quantity for Item {0},Ilość Przyjętych + Odrzuconych musi odpowiadać ilości Odebranych (Element {0}),
-Access Token,Dostęp za pomocą Tokenu,
-Accessable Value,Dostępna wartość,
-Account,Konto,
-Account Number,Numer konta,
-Account Number {0} already used in account {1},Numer konta {0} jest już używany na koncie {1},
-Account Pay Only,Tylko płatne konto,
-Account Type,typ konta,
-Account Type for {0} must be {1},Typ konta dla {0} musi być {1},
-"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Konto jest na minusie, nie możesz ustawić wymagań jako debet.",
-"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Konto jest na minusie, nie możesz ustawić wymagań jako kredyt.",
-Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Numer konta dla konta {0} jest niedostępny. <br> Skonfiguruj poprawnie swój plan kont.,
-Account with child nodes cannot be converted to ledger,Konto grupujące inne konta nie może być konwertowane,
-Account with child nodes cannot be set as ledger,Konto z węzłów podrzędnych nie może być ustawiony jako księgi,
-Account with existing transaction can not be converted to group.,Konto z istniejącymi zapisami nie może być konwertowane na Grupę (konto dzielone).,
-Account with existing transaction can not be deleted,Konto z istniejącymi zapisami nie może być usunięte,
-Account with existing transaction cannot be converted to ledger,Konto z istniejącymi zapisami nie może być konwertowane,
-Account {0} does not belong to company: {1},Konto {0} nie należy do firmy: {1},
-Account {0} does not belongs to company {1},Konto {0} nie należy do firmy {1},
-Account {0} does not exist,Konto {0} nie istnieje,
-Account {0} does not exists,Konto {0} nie istnieje,
-Account {0} does not match with Company {1} in Mode of Account: {2},Konto {0} nie jest zgodne z firmą {1} w trybie konta: {2},
-Account {0} has been entered multiple times,Konto {0} zostało wprowadzone wielokrotnie,
-Account {0} is added in the child company {1},Konto {0} zostało dodane w firmie podrzędnej {1},
-Account {0} is frozen,Konto {0} jest zamrożone,
-Account {0} is invalid. Account Currency must be {1},Konto {0} jest nieprawidłowe. Waluta konta musi być {1},
-Account {0}: Parent account {1} can not be a ledger,Konto {0}: Nadrzędne konto {1} nie może być zwykłym,
-Account {0}: Parent account {1} does not belong to company: {2},Konto {0}: konto nadrzędne {1} nie należy do firmy: {2},
-Account {0}: Parent account {1} does not exist,Konto {0}: Konto nadrzędne {1} nie istnieje,
-Account {0}: You can not assign itself as parent account,Konto {0}: Nie można przypisać siebie jako konta nadrzędnego,
-Account: {0} can only be updated via Stock Transactions,Konto: {0} może być aktualizowana tylko przez operacje magazynowe,
-Account: {0} with currency: {1} can not be selected,Konto: {0} z waluty: nie można wybrać {1},
-Accountant,Księgowy,
-Accounting,Księgowość,
-Accounting Entry for Asset,Zapis Księgowy dla aktywów,
-Accounting Entry for Stock,Zapis księgowy dla zapasów,
-Accounting Entry for {0}: {1} can only be made in currency: {2},Wprowadzenia danych księgowych dla {0}: {1} może być dokonywane wyłącznie w walucie: {2},
-Accounting Ledger,Księgi rachunkowe,
-Accounting journal entries.,Dziennik zapisów księgowych.,
-Accounts,Księgowość,
-Accounts Manager,Specjalista ds. Sprzedaży,
-Accounts Payable,Zobowiązania,
-Accounts Payable Summary,Zobowiązania Podsumowanie,
-Accounts Receivable,Należności,
-Accounts Receivable Summary,Należności Podsumowanie,
-Accounts User,Konta Użytkownika,
-Accounts table cannot be blank.,Tabela kont nie może być pusta,
-Accrual Journal Entry for salaries from {0} to {1},Zapis wstępny w dzienniku dla zarobków od {0} do {1},
-Accumulated Depreciation,Umorzenia (skumulowana amortyzacja),
-Accumulated Depreciation Amount,Kwota Skumulowanej amortyzacji,
-Accumulated Depreciation as on,Skumulowana amortyzacja jak na,
-Accumulated Monthly,skumulowane miesięcznie,
-Accumulated Values,Skumulowane wartości,
-Accumulated Values in Group Company,Skumulowane wartości w Spółce Grupy,
-Achieved ({}),Osiągnięto ({}),
-Action,Działanie,
-Action Initialised,Działanie zainicjowane,
-Actions,działania,
-Active,Aktywny,
-Activity Cost exists for Employee {0} against Activity Type - {1},Istnieje aktywny Koszt Pracodawcy {0} przed Type Aktywny - {1},
-Activity Cost per Employee,Koszt aktywność na pracownika,
-Activity Type,Rodzaj aktywności,
-Actual Cost,Aktualna cena,
-Actual Delivery Date,Rzeczywista data dostawy,
-Actual Qty,Rzeczywista ilość,
-Actual Qty is mandatory,Rzeczywista ilość jest obowiązkowa,
-Actual Qty {0} / Waiting Qty {1},Rzeczywista ilość {0} / liczba oczekujących {1},
-Actual Qty: Quantity available in the warehouse.,Rzeczywista ilość: ilość dostępna w magazynie.,
-Actual qty in stock,Rzeczywista ilość w magazynie,
-Actual type tax cannot be included in Item rate in row {0},Rzeczywista Podatek typu nie mogą być wliczone w cenę towaru w wierszu {0},
-Add,Dodaj,
-Add / Edit Prices,Dodaj / edytuj ceny,
-Add Comment,Dodaj komentarz,
-Add Customers,Dodaj klientów,
-Add Employees,Dodaj pracowników,
-Add Item,Dodaj pozycję,
-Add Items,Dodaj pozycje,
-Add Leads,Dodaj namiary,
-Add Multiple Tasks,Dodaj wiele zadań,
-Add Row,Dodaj wiersz,
-Add Sales Partners,Dodaj partnerów handlowych,
-Add Serial No,Dodaj nr seryjny,
-Add Students,Dodaj uczniów,
-Add Suppliers,Dodaj dostawców,
-Add Time Slots,Dodaj gniazda czasowe,
-Add Timesheets,Dodaj ewidencja czasu pracy,
-Add Timeslots,Dodaj czasopisma,
-Add Users to Marketplace,Dodaj użytkowników do rynku,
-Add a new address,Dodaj nowy adres,
-Add cards or custom sections on homepage,Dodaj karty lub niestandardowe sekcje na stronie głównej,
-Add more items or open full form,Dodać więcej rzeczy lub otworzyć pełną formę,
-Add notes,Dodaj notatki,
-Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,Dodać resztę organizacji jako użytkowników. Można również dodać zaprosić klientów do portalu dodając je z Kontaktów,
-Add to Details,Dodaj do szczegółów,
-Add/Remove Recipients,Dodaj / usuń odbiorców,
-Added,Dodano,
-Added to details,Dodano do szczegółów,
-Added {0} users,Dodano {0} użytkowników,
-Additional Salary Component Exists.,Istnieje dodatkowy składnik wynagrodzenia.,
-Address,Adres,
-Address Line 2,Drugi wiersz adresu,
-Address Name,Adres,
-Address Title,Tytuł adresu,
-Address Type,Typ adresu,
-Administrative Expenses,Wydatki na podstawową działalność,
-Administrative Officer,Urzędnik administracyjny,
-Administrator,Administrator,
-Admission,Wstęp,
-Admission and Enrollment,Wstęp i rejestracja,
-Admissions for {0},Rekrutacja dla {0},
-Admit,Przyznać,
-Admitted,Przyznał,
-Advance Amount,Kwota Zaliczki,
-Advance Payments,Zaliczki,
-Advance account currency should be same as company currency {0},"Waluta konta Advance powinna być taka sama, jak waluta firmy {0}",
-Advance amount cannot be greater than {0} {1},Ilość wyprzedzeniem nie może być większa niż {0} {1},
-Advertising,Reklamowanie,
-Aerospace,Lotnictwo,
-Against,Wyklucza,
-Against Account,Konto korespondujące,
-Against Journal Entry {0} does not have any unmatched {1} entry,Przeciwko Urzędowym Wejście {0} nie ma niezrównaną pozycję {1},
-Against Journal Entry {0} is already adjusted against some other voucher,Zapis {0} jest już powiązany z innym dowodem księgowym,
-Against Supplier Invoice {0} dated {1},Przeciwko Dostawcę faktury {0} {1} dnia,
-Against Voucher,Dowód księgowy,
-Against Voucher Type,Rodzaj dowodu,
-Age,Wiek,
-Age (Days),Wiek (dni),
-Ageing Based On,,
-Ageing Range 1,Starzenie Zakres 1,
-Ageing Range 2,Starzenie Zakres 2,
-Ageing Range 3,Starzenie Zakres 3,
-Agriculture,Rolnictwo,
-Agriculture (beta),Rolnictwo (beta),
-Airline,Linia lotnicza,
-All Accounts,Wszystkie konta,
-All Addresses.,Wszystkie adresy,
-All Assessment Groups,Wszystkie grupy oceny,
-All BOMs,Wszystkie LM,
-All Contacts.,Wszystkie kontakty.,
-All Customer Groups,Wszystkie grupy klientów,
-All Day,Cały Dzień,
-All Departments,Wszystkie departamenty,
-All Healthcare Service Units,Wszystkie jednostki służby zdrowia,
-All Item Groups,Wszystkie grupy produktów,
-All Jobs,Wszystkie Oferty pracy,
-All Products,Wszystkie produkty,
-All Products or Services.,Wszystkie produkty i usługi.,
-All Student Admissions,Wszystkie Przyjęć studenckie,
-All Supplier Groups,Wszystkie grupy dostawców,
-All Supplier scorecards.,Wszystkie karty oceny dostawcy.,
-All Territories,Wszystkie obszary,
-All Warehouses,Wszystkie magazyny,
-All communications including and above this shall be moved into the new Issue,"Wszystkie komunikaty, w tym i powyżej tego, zostaną przeniesione do nowego wydania",
-All items have already been transferred for this Work Order.,Wszystkie przedmioty zostały już przekazane dla tego zlecenia pracy.,
-All other ITC,Wszystkie inne ITC,
-All the mandatory Task for employee creation hasn't been done yet.,Wszystkie obowiązkowe zadanie tworzenia pracowników nie zostało jeszcze wykonane.,
-Allocate Payment Amount,Przeznaczyć Kwota płatności,
-Allocated Amount,Przyznana kwota,
-Allocated Leaves,Przydzielone Nieobecności,
-Allocating leaves...,Przydzielanie Nieobecności...,
-Already record exists for the item {0},Już istnieje rekord dla elementu {0},
-"Already set default in pos profile {0} for user {1}, kindly disabled default","Już ustawiono domyślne w profilu pozycji {0} dla użytkownika {1}, domyślnie wyłączone",
-Alternate Item,Alternatywna pozycja,
-Alternative item must not be same as item code,"Element alternatywny nie może być taki sam, jak kod produktu",
-Amended From,Zmodyfikowany od,
-Amount,Wartość,
-Amount After Depreciation,Kwota po amortyzacji,
-Amount of Integrated Tax,Kwota Zintegrowanego Podatku,
-Amount of TDS Deducted,Kwota potrąconej TDS,
-Amount should not be less than zero.,Kwota nie powinna być mniejsza niż zero.,
-Amount to Bill,Kwota rachunku,
-Amount {0} {1} against {2} {3},Kwota {0} {1} przeciwko {2} {3},
-Amount {0} {1} deducted against {2},Kwota {0} {1} odliczone przed {2},
-Amount {0} {1} transferred from {2} to {3},"Kwota {0} {1} przeniesione z {2} {3}, aby",
-Amount {0} {1} {2} {3},Kwota {0} {1} {2} {3},
-Amt,Amt,
-"An Item Group exists with same name, please change the item name or rename the item group",Istnieje element Grupy o takiej nazwie. Zmień nazwę elementu lub tamtej Grupy.,
-An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Semestr z tym &quot;Roku Akademickiego&quot; {0} i &#39;Nazwa Termin&#39; {1} już istnieje. Proszę zmodyfikować te dane i spróbuj jeszcze raz.,
-An error occurred during the update process,Wystąpił błąd podczas procesu aktualizacji,
-"An item exists with same name ({0}), please change the item group name or rename the item",Istnieje element  o takiej nazwie. Zmień nazwę Grupy lub tego elementu.,
-Analyst,Analityk,
-Analytics,Analityk,
-Annual Billing: {0},Roczne rozliczeniowy: {0},
-Annual Salary,Roczne wynagrodzenie,
-Anonymous,Anonimowy,
-Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},Inny rekord budżetu &quot;{0}&quot; już istnieje w stosunku do {1} &quot;{2}&quot; i konta &quot;{3}&quot; w roku finansowym {4},
-Another Period Closing Entry {0} has been made after {1},Kolejny okres Zamknięcie Wejście {0} została wykonana po {1},
-Another Sales Person {0} exists with the same Employee id,Inna osoba Sprzedaż {0} istnieje w tym samym identyfikator pracownika,
-Antibiotic,Antybiotyk,
-Apparel & Accessories,Odzież i akcesoria,
-Applicable For,Stosowne dla,
-"Applicable if the company is SpA, SApA or SRL","Stosuje się, jeśli spółką jest SpA, SApA lub SRL",
-Applicable if the company is a limited liability company,"Stosuje się, jeśli firma jest spółką z ograniczoną odpowiedzialnością",
-Applicable if the company is an Individual or a Proprietorship,"Stosuje się, jeśli firma jest jednostką lub właścicielem",
-Applicant,Petent,
-Applicant Type,Typ Wnioskodawcy,
-Application of Funds (Assets),Aktywa,
-Application period cannot be across two allocation records,Okres aplikacji nie może mieć dwóch rekordów przydziału,
-Application period cannot be outside leave allocation period,Wskazana data nieobecności nie może wykraczać poza zaalokowany okres dla nieobecności,
-Applied,Stosowany,
-Apply Now,Aplikuj teraz,
-Appointment Confirmation,Potwierdzenie spotkania,
-Appointment Duration (mins),Czas trwania spotkania (min),
-Appointment Type,Typ spotkania,
-Appointment {0} and Sales Invoice {1} cancelled,Mianowanie {0} i faktura sprzedaży {1} zostały anulowane,
-Appointments and Encounters,Spotkania i spotkania,
-Appointments and Patient Encounters,Spotkania i spotkania z pacjentami,
-Appraisal {0} created for Employee {1} in the given date range,Ocena {0} utworzona dla Pracownika {1} w datach od-do,
-Apprentice,Uczeń,
-Approval Status,Status Zatwierdzenia,
-Approval Status must be 'Approved' or 'Rejected',Status Zatwierdzenia musi być 'Zatwierdzono' albo 'Odrzucono',
-Approve,Zatwierdzać,
-Approving Role cannot be same as role the rule is Applicable To,Rola Zatwierdzająca nie może być taka sama jak rola którą zatwierdza,
-Approving User cannot be same as user the rule is Applicable To,"Zatwierdzający Użytkownik nie może być taki sam, jak użytkownik którego zatwierdza",
-"Apps using current key won't be able to access, are you sure?","Aplikacje używające obecnego klucza nie będą mogły uzyskać dostępu, czy na pewno?",
-Are you sure you want to cancel this appointment?,Czy na pewno chcesz anulować to spotkanie?,
-Arrear,Zaległość,
-As Examiner,Jako egzaminator,
-As On Date,W sprawie daty,
-As Supervisor,Jako Supervisor,
-As per rules 42 & 43 of CGST Rules,Zgodnie z zasadami 42 i 43 Regulaminu CGST,
-As per section 17(5),Jak w sekcji 17 (5),
-As per your assigned Salary Structure you cannot apply for benefits,Zgodnie z przypisaną Ci strukturą wynagrodzeń nie możesz ubiegać się o świadczenia,
-Assessment,Oszacowanie,
-Assessment Criteria,Kryteria oceny,
-Assessment Group,Grupa Assessment,
-Assessment Group: ,Grupa oceny:,
-Assessment Plan,Plan oceny,
-Assessment Plan Name,Nazwa planu oceny,
-Assessment Report,Sprawozdanie z oceny,
-Assessment Reports,Raporty z oceny,
-Assessment Result,Wynik oceny,
-Assessment Result record {0} already exists.,Wynik Wynik {0} już istnieje.,
-Asset,Składnik aktywów,
-Asset Category,Aktywa Kategoria,
-Asset Category is mandatory for Fixed Asset item,Kategoria atutem jest obowiązkowe dla Fixed pozycja aktywów,
-Asset Maintenance,Konserwacja aktywów,
-Asset Movement,Zaleta Ruch,
-Asset Movement record {0} created,Rekord Ruch atutem {0} tworzone,
-Asset Name,Zaleta Nazwa,
-Asset Received But Not Billed,"Zasoby odebrane, ale nieopłacone",
-Asset Value Adjustment,Korekta wartości aktywów,
-"Asset cannot be cancelled, as it is already {0}","Aktywów nie mogą być anulowane, ponieważ jest już {0}",
-Asset scrapped via Journal Entry {0},Zaleta złomowany poprzez Journal Entry {0},
-"Asset {0} cannot be scrapped, as it is already {1}","Składnik {0} nie może zostać wycofane, jak to jest już {1}",
-Asset {0} does not belong to company {1},Zaleta {0} nie należą do firmy {1},
-Asset {0} must be submitted,Zaleta {0} należy składać,
-Assets,Majątek,
-Assign,Przydziel,
-Assign Salary Structure,Przypisanie struktury wynagrodzeń,
-Assign To,Przypisano do,
-Assign to Employees,Przypisz do pracowników,
-Assigning Structures...,Przyporządkowywanie Struktur,
-Associate,Współpracownik,
-At least one mode of payment is required for POS invoice.,Co najmniej jeden tryb płatności POS jest wymagane dla faktury.,
-Atleast one item should be entered with negative quantity in return document,Conajmniej jedna pozycja powinna być wpisana w ilości negatywnej w dokumencie powrotnej,
-Atleast one of the Selling or Buying must be selected,Conajmniej jeden sprzedaż lub zakup musi być wybrany,
-Atleast one warehouse is mandatory,Co najmniej jeden magazyn jest wymagany,
-Attach Logo,Załącz Logo,
-Attachment,Załącznik,
-Attachments,Załączniki,
-Attendance,Obecność,
-Attendance From Date and Attendance To Date is mandatory,Obecnośc od i do Daty są obowiązkowe,
-Attendance can not be marked for future dates,Obecność nie może być oznaczana na przyszłość,
-Attendance date can not be less than employee's joining date,data frekwencja nie może być mniejsza niż data łączącej pracownika,
-Attendance for employee {0} is already marked,Frekwencja pracownika {0} jest już zaznaczona,
-Attendance for employee {0} is already marked for this day,Frekwencja na pracownika {0} jest już zaznaczone na ten dzień,
-Attendance has been marked successfully.,Obecność została oznaczona pomyślnie.,
-Attendance not submitted for {0} as it is a Holiday.,"Frekwencja nie została przesłana do {0}, ponieważ jest to święto.",
-Attendance not submitted for {0} as {1} on leave.,Obecność nie została przesłana do {0} jako {1} podczas nieobecności.,
-Attribute table is mandatory,Stół atrybut jest obowiązkowy,
-Attribute {0} selected multiple times in Attributes Table,Atrybut {0} wybrane atrybuty kilka razy w tabeli,
-Author,Autor,
-Authorized Signatory,Upoważniony sygnatariusz,
-Auto Material Requests Generated,Wnioski Auto Materiał Generated,
-Auto Repeat,Auto Repeat,
-Auto repeat document updated,Automatycznie powtórzony dokument został zaktualizowany,
-Automotive,,
-Available,Dostępny,
-Available Leaves,Dostępne Nieobecności,
-Available Qty,Dostępne szt,
-Available Selling,Dostępne sprzedawanie,
-Available for use date is required,Dostępna jest data przydatności do użycia,
-Available slots,Dostępne gniazda,
-Available {0},Dostępne {0},
-Available-for-use Date should be after purchase date,Data przydatności do użycia powinna być późniejsza niż data zakupu,
-Average Age,Średni wiek,
-Average Rate,Średnia Stawka,
-Avg Daily Outgoing,Średnia dzienna Wychodzące,
-Avg. Buying Price List Rate,Śr. Kupowanie kursu cenowego,
-Avg. Selling Price List Rate,Śr. Wskaźnik cen sprzedaży,
-Avg. Selling Rate,Średnia. Cena sprzedaży,
-BOM,BOM,
-BOM Browser,Przeglądarka BOM,
-BOM No,Nr zestawienia materiałowego,
-BOM Rate,BOM Kursy,
-BOM Stock Report,BOM Zdjęcie Zgłoś,
-BOM and Manufacturing Quantity are required,BOM i ilości są wymagane Manufacturing,
-BOM does not contain any stock item,BOM nie zawiera żadnego elementu akcji,
-BOM {0} does not belong to Item {1},BOM {0} nie należy do pozycji {1},
-BOM {0} must be active,BOM {0} musi być aktywny,
-BOM {0} must be submitted,BOM {0} musi być złożony,
-Balance,Bilans,
-Balance (Dr - Cr),Balans (Dr - Cr),
-Balance ({0}),Saldo ({0}),
-Balance Qty,Ilość bilansu,
-Balance Sheet,Arkusz Bilansu,
-Balance Value,Wartość bilansu,
-Balance for Account {0} must always be {1},Bilans dla Konta {0} zawsze powinien wynosić {1},
-Bank,Bank,
-Bank Account,Konto bankowe,
-Bank Accounts,Konta bankowe,
-Bank Draft,Przekaz bankowy,
-Bank Entries,Operacje bankowe,
-Bank Name,Nazwa banku,
-Bank Overdraft Account,Konto z kredytem w rachunku bankowym,
-Bank Reconciliation,Uzgodnienia z wyciągiem bankowym,
-Bank Reconciliation Statement,Stan uzgodnień z wyciągami z banku,
-Bank Statement,Wyciąg bankowy,
-Bank Statement Settings,Ustawienia wyciągu bankowego,
-Bank Statement balance as per General Ledger,Bilans wyciągów bankowych wedle Księgi Głównej,
-Bank account cannot be named as {0},Rachunku bankowego nie może być nazwany {0},
-Bank/Cash transactions against party or for internal transfer,Transakcje Bank / Gotówka przeciwko osobie lub do przenoszenia wewnętrznego,
-Banking,Bankowość,
-Banking and Payments,Operacje bankowe i płatności,
-Barcode {0} already used in Item {1},Kod kreskowy {0} jest już używany dla przedmiotu {1},
-Barcode {0} is not a valid {1} code,Kod kreskowy {0} nie jest prawidłowym kodem {1},
-Base,Baza,
-Base URL,Podstawowy adres URL,
-Based On,Bazujący na,
-Based On Payment Terms,Bazując na Zasadach Płatności,
-Basic,Podstawowy,
-Batch,Partia,
-Batch Entries,Wpisy wsadowe,
-Batch ID is mandatory,Identyfikator zbiorczy jest obowiązkowy,
-Batch Inventory,Inwentaryzacja partii,
-Batch Name,Batch Nazwa,
-Batch No,Nr Partii,
-Batch number is mandatory for Item {0},Numer partii jest obowiązkowy dla produktu {0},
-Batch {0} of Item {1} has expired.,Batch {0} pozycji {1} wygasł.,
-Batch {0} of Item {1} is disabled.,Partia {0} elementu {1} jest wyłączona.,
-Batch: ,Partia:,
-Batches,Partie,
-Become a Seller,Zostań sprzedawcą,
-Beginner,Początkujący,
-Bill,Rachunek,
-Bill Date,Data Rachunku,
-Bill No,Numer Rachunku,
-Bill of Materials,Zestawienie materiałów,
-Bill of Materials (BOM),Zestawienie materiałowe (BOM),
-Billable Hours,Rozliczalne godziny,
-Billed,Rozliczony,
-Billed Amount,Ilość Rozliczenia,
-Billing,Dane do faktury,
-Billing Address,Adres Faktury,
-Billing Address is same as Shipping Address,"Adres rozliczeniowy jest taki sam, jak adres wysyłki",
-Billing Amount,Kwota Rozliczenia,
-Billing Status,Status Faktury,
-Billing currency must be equal to either default company's currency or party account currency,Waluta rozliczeniowa musi być równa domyślnej walucie firmy lub walucie konta strony,
-Bills raised by Suppliers.,Rachunki od dostawców.,
-Bills raised to Customers.,Rachunki dla klientów.,
-Biotechnology,Biotechnologia,
-Birthday Reminder,Przypomnienie o urodzinach,
-Black,czarny,
-Blanket Orders from Costumers.,Zamówienia zbiorcze od klientów.,
-Block Invoice,Zablokuj fakturę,
-Boms,Bomy,
-Bonus Payment Date cannot be a past date,Data płatności premii nie może być datą przeszłą,
-Both Trial Period Start Date and Trial Period End Date must be set,"Należy ustawić zarówno datę rozpoczęcia okresu próbnego, jak i datę zakończenia okresu próbnego",
-Both Warehouse must belong to same Company,Obydwa Magazyny muszą należeć do tej samej firmy,
-Branch,Odddział,
-Broadcasting,Transmitowanie,
-Brokerage,Pośrednictwo,
-Browse BOM,Przeglądaj BOM,
-Budget Against,budżet Against,
-Budget List,Lista budżetu,
-Budget Variance Report,Raport z weryfikacji budżetu,
-Budget cannot be assigned against Group Account {0},Budżet nie może być przypisany do rachunku grupy {0},
-"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Budżet nie może być przypisany przed {0}, ponieważ nie jest to konto przychodów lub kosztów",
-Buildings,Budynki,
-Bundle items at time of sale.,Pakiet przedmiotów w momencie sprzedaży,
-Business Development Manager,Business Development Manager,
-Buy,Kup,
-Buying,Zakupy,
-Buying Amount,Kwota zakupu,
-Buying Price List,Kupowanie cennika,
-Buying Rate,Cena zakupu,
-"Buying must be checked, if Applicable For is selected as {0}","Zakup musi być sprawdzona, jeśli dotyczy wybrano jako {0}",
-By {0},Do {0},
-Bypass credit check at Sales Order ,Pomiń kontrolę kredytową w zleceniu sprzedaży,
-C-Form records,,
-C-form is not applicable for Invoice: {0},C-forma nie ma zastosowania do faktury: {0},
-CEO,CEO,
-CESS Amount,Kwota CESS,
-CGST Amount,CGST Kwota,
-CRM,CRM,
-CWIP Account,Konto CWIP,
-Calculated Bank Statement balance,Obliczony bilans wyciągu bankowego,
-Calls,Połączenia,
-Campaign,Kampania,
-Can be approved by {0},Może być zatwierdzone przez {0},
-"Can not filter based on Account, if grouped by Account","Nie można przefiltrować na podstawie Konta, jeśli pogrupowano z użuciem konta",
-"Can not filter based on Voucher No, if grouped by Voucher","Nie można przefiltrować wg Podstawy, jeśli pogrupowano z użyciem Podstawy",
-"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Nie można oznaczyć rekordu rozładowania szpitala, istnieją niezafakturowane faktury {0}",
-Can only make payment against unbilled {0},Mogą jedynie wpłaty przed Unbilled {0},
-Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Może odnosić się do wierdza tylko wtedy, gdy typ opłata jest ""Poprzedniej Wartości Wiersza Suma"" lub ""poprzedniego wiersza Razem""",
-"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Nie można zmienić metody wyceny, ponieważ istnieją transakcje dotyczące niektórych pozycji, które nie mają własnej metody wyceny",
-Can't create standard criteria. Please rename the criteria,Nie można utworzyć standardowych kryteriów. Zmień nazwę kryteriów,
-Cancel,Anuluj,
-Cancel Material Visit {0} before cancelling this Warranty Claim,Anuluj Materiał Odwiedź {0} zanim anuluje to roszczenia z tytułu gwarancji,
-Cancel Material Visits {0} before cancelling this Maintenance Visit,Anuluj Fizyczne Wizyty {0} zanim anulujesz Wizytę Pośrednią,
-Cancel Subscription,Anuluj subskrypcje,
-Cancel the journal entry {0} first,Najpierw anuluj zapis księgowy {0},
-Canceled,Anulowany,
-"Cannot Submit, Employees left to mark attendance","Nie można przesłać, pracownicy zostali pozostawieni, aby zaznaczyć frekwencję",
-Cannot be a fixed asset item as Stock Ledger is created.,"Nie może być pozycją środka trwałego, ponieważ tworzona jest księga zapasowa.",
-Cannot cancel because submitted Stock Entry {0} exists,"Nie można anulować, ponieważ wskazane Wprowadzenie na magazyn {0} istnieje",
-Cannot cancel transaction for Completed Work Order.,Nie można anulować transakcji dotyczącej ukończonego zlecenia pracy.,
-Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},"Nie można anulować {0} {1}, ponieważ numer seryjny {2} nie należy do magazynu {3}",
-Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Nie można zmienić atrybutów po transakcji giełdowej. Zrób nowy przedmiot i prześlij towar do nowego przedmiotu,
-Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,"Nie można zmienić Rok obrotowy Data rozpoczęcia i Data zakończenia roku obrotowego, gdy rok obrotowy jest zapisane.",
-Cannot change Service Stop Date for item in row {0},Nie można zmienić daty zatrzymania usługi dla pozycji w wierszu {0},
-Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,"Nie można zmienić właściwości wariantu po transakcji giełdowej. Będziesz musiał zrobić nową rzecz, aby to zrobić.",
-"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Nie można zmienić domyślnej waluty firmy, ponieważ istnieją przypisane do niej transakcje. Anuluj transakcje, aby zmienić domyślną walutę",
-Cannot change status as student {0} is linked with student application {1},Nie można zmienić status studenta {0} jest powiązany z aplikacją studentów {1},
-Cannot convert Cost Center to ledger as it has child nodes,"Nie można przekonwertować centrum kosztów do księgi głównej, jak to ma węzły potomne",
-Cannot covert to Group because Account Type is selected.,"Nie można konwertowanie do grupy, ponieważ jest wybrany rodzaj konta.",
-Cannot create Retention Bonus for left Employees,Nie można utworzyć bonusu utrzymania dla leworęcznych pracowników,
-Cannot create a Delivery Trip from Draft documents.,Nie można utworzyć podróży dostawy z dokumentów roboczych.,
-Cannot deactivate or cancel BOM as it is linked with other BOMs,Nie można wyłączyć lub anulować LM jak to jest połączone z innymi LM,
-"Cannot declare as lost, because Quotation has been made.",Nie można zadeklarować jako zagubiony z powodu utworzenia kwotacji,
-Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Nie można wywnioskować, kiedy kategoria dotyczy ""Ocena"" a kiedy ""Oceny i Total""",
-Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',"Nie można odliczyć, gdy kategoria jest dla &#39;Wycena&#39; lub &#39;Vaulation i Total&#39;",
-"Cannot delete Serial No {0}, as it is used in stock transactions","Nie można usunąć nr seryjnego {0}, ponieważ jest wykorzystywany w transakcjach magazynowych",
-Cannot enroll more than {0} students for this student group.,Nie można zapisać więcej niż {0} studentów dla tej grupy studentów.,
-Cannot find active Leave Period,Nie można znaleźć aktywnego Okresu Nieobecności,
-Cannot produce more Item {0} than Sales Order quantity {1},Nie można wyprodukować więcej przedmiotów {0} niż wartość {1} na Zamówieniu,
-Cannot promote Employee with status Left,Nie można promować pracownika z pozostawionym statusem,
-Cannot refer row number greater than or equal to current row number for this Charge type,Nie można wskazać numeru wiersza większego lub równego numerowi dla tego typu Opłaty,
-Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Nie można wybrać typu opłaty jako ""Sumy Poprzedniej Komórki"" lub ""Całkowitej kwoty poprzedniej Komórki"" w pierwszym rzędzie",
-Cannot set as Lost as Sales Order is made.,Nie można ustawić jako Utracone Zamówienia Sprzedaży,
-Cannot set authorization on basis of Discount for {0},Nie można ustawić autoryzacji na podstawie Zniżki dla {0},
-Cannot set multiple Item Defaults for a company.,Nie można ustawić wielu wartości domyślnych dla danej firmy.,
-Cannot set quantity less than delivered quantity,Nie można ustawić ilości mniejszej niż dostarczona ilość,
-Cannot set quantity less than received quantity,Nie można ustawić ilości mniejszej niż ilość odebrana,
-Cannot set the field <b>{0}</b> for copying in variants,Nie można ustawić pola <b>{0}</b> do kopiowania w wariantach,
-Cannot transfer Employee with status Left,Nie można przenieść pracownika ze statusem w lewo,
-Cannot {0} {1} {2} without any negative outstanding invoice,Nie można {0} {1} {2} bez negatywnego wybitne faktury,
-Capital Equipments,Wyposażenie Kapitałowe,
-Capital Stock,Kapitał zakładowy,
-Capital Work in Progress,Praca kapitałowa w toku,
-Cart,Koszyk,
-Cart is Empty,Koszyk jest pusty,
-Case No(s) already in use. Try from Case No {0},Numer(y) sprawy w użytku. Proszę spróbować Numer Sprawy {0},
-Cash,Gotówka,
-Cash Flow Statement,Raport kasowy,
-Cash Flow from Financing,Cash Flow z finansowania,
-Cash Flow from Investing,Przepływy środków pieniężnych z Inwestowanie,
-Cash Flow from Operations,Przepływy środków pieniężnych z działalności operacyjnej,
-Cash In Hand,Gotówka w kasie,
-Cash or Bank Account is mandatory for making payment entry,Konto Gotówka lub Bank jest wymagane dla tworzenia zapisów Płatności,
-Cashier Closing,Zamknięcie kasjera,
-Casual Leave,Urlop okolicznościowy,
-Category,Kategoria,
-Category Name,Nazwa kategorii,
-Caution,Uwaga,
-Central Tax,Podatek centralny,
-Certification,Orzecznictwo,
-Cess,Cess,
-Change Amount,Zmień Kwota,
-Change Item Code,Zmień kod przedmiotu,
-Change Release Date,Zmień datę wydania,
-Change Template Code,Zmień kod szablonu,
-Changing Customer Group for the selected Customer is not allowed.,Zmiana grupy klientów dla wybranego klienta jest niedozwolona.,
-Chapter,Rozdział,
-Chapter information.,Informacje o rozdziale.,
-Charge of type 'Actual' in row {0} cannot be included in Item Rate,,
-Chargeble,Chargeble,
-Charges are updated in Purchase Receipt against each item,Opłaty są aktualizowane w ZAKUPU każdej pozycji,
-"Charges will be distributed proportionately based on item qty or amount, as per your selection","Koszty zostaną rozdzielone proporcjonalnie na podstawie Ilość pozycji lub kwoty, jak na swój wybór",
-Chart of Cost Centers,Struktura kosztów (MPK),
-Check all,Zaznacz wszystkie,
-Checkout,Sprawdzić,
-Chemical,Chemiczny,
-Cheque,Czek,
-Cheque/Reference No,Czek / numer,
-Cheques Required,Wymagane kontrole,
-Cheques and Deposits incorrectly cleared,Czeki i Depozyty nieprawidłowo rozliczone,
-Child Task exists for this Task. You can not delete this Task.,Dla tego zadania istnieje zadanie podrzędne. Nie możesz usunąć tego zadania.,
-Child nodes can be only created under 'Group' type nodes,węzły potomne mogą być tworzone tylko w węzłach typu &quot;grupa&quot;,
-Child warehouse exists for this warehouse. You can not delete this warehouse.,Magazyn Dziecko nie istnieje dla tego magazynu. Nie można usunąć tego magazynu.,
-Circular Reference Error,Circular Error Referencje,
-City,Miasto,
-City/Town,Miasto/Miejscowość,
-Claimed Amount,Kwota roszczenia,
-Clay,Glina,
-Clear filters,Wyczyść filtry,
-Clear values,Wyczyść wartości,
-Clearance Date,Data Czystki,
-Clearance Date not mentioned,,
-Clearance Date updated,Rozliczenie Data aktualizacji,
-Client,Klient,
-Client ID,Identyfikator klienta,
-Client Secret,Klient Secret,
-Clinical Procedure,Procedura kliniczna,
-Clinical Procedure Template,Szablon procedury klinicznej,
-Close Balance Sheet and book Profit or Loss.,Sporządzenie Bilansu oraz Rachunku zysków i strat.,
-Close Loan,Zamknij pożyczkę,
-Close the POS,Zamknij punkt sprzedaży,
-Closed,Zamknięte,
-Closed order cannot be cancelled. Unclose to cancel.,Kolejność Zamknięty nie mogą być anulowane. Unclose aby anulować.,
-Closing (Cr),Zamknięcie (Cr),
-Closing (Dr),Zamknięcie (Dr),
-Closing (Opening + Total),Zamknięcie (otwarcie + suma),
-Closing Account {0} must be of type Liability / Equity,Zamknięcie konta {0} musi być typu odpowiedzialności / Equity,
-Closing Balance,Bilans zamknięcia,
-Code,Kod,
-Collapse All,Zwinąć wszystkie,
-Color,Kolor,
-Colour,Kolor,
-Combined invoice portion must equal 100%,Łączna kwota faktury musi wynosić 100%,
-Commercial,Komercyjny,
-Commission,Prowizja,
-Commission Rate %,Stawka prowizji%,
-Commission on Sales,Prowizja od sprzedaży,
-Commission rate cannot be greater than 100,Wartość prowizji nie może być większa niż 100,
-Community Forum,Społeczność Forum,
-Company (not Customer or Supplier) master.,Informacje o własnej firmie.,
-Company Abbreviation,Nazwa skrótowa firmy,
-Company Abbreviation cannot have more than 5 characters,Skrót firmy nie może zawierać więcej niż 5 znaków,
-Company Name,Nazwa firmy,
-Company Name cannot be Company,Nazwa firmy nie może być firmą,
-Company currencies of both the companies should match for Inter Company Transactions.,Waluty firmy obu spółek powinny być zgodne z Transakcjami między spółkami.,
-Company is manadatory for company account,Firma jest manadatory dla konta firmowego,
-Company name not same,Nazwa firmy nie jest taka sama,
-Company {0} does not exist,Firma {0} nie istnieje,
-Compensatory Off,,
-Compensatory leave request days not in valid holidays,Dni urlopu wyrównawczego nie zawierają się w zakresie prawidłowych dniach świątecznych,
-Complaint,Skarga,
-Completion Date,Data ukończenia,
-Computer,Komputer,
-Condition,Stan,
-Configure,Konfiguruj,
-Configure {0},Konfiguruj {0},
-Confirmed orders from Customers.,Potwierdzone zamówienia od klientów,
-Connect Amazon with ERPNext,Połącz Amazon z ERPNext,
-Connect Shopify with ERPNext,Połącz Shopify z ERPNext,
-Connect to Quickbooks,Połącz się z Quickbooks,
-Connected to QuickBooks,Połączony z QuickBooks,
-Connecting to QuickBooks,Łączenie z QuickBookami,
-Consultation,Konsultacja,
-Consultations,Konsultacje,
-Consulting,Konsulting,
-Consumable,Konsumpcyjny,
-Consumed,Skonsumowano,
-Consumed Amount,Skonsumowana wartość,
-Consumed Qty,Skonsumowana ilość,
-Consumer Products,Produkty konsumenckie,
-Contact,Kontakt,
-Contact Details,Szczegóły kontaktu,
-Contact Number,Numer kontaktowy,
-Contact Us,Skontaktuj się z nami,
-Content,Zawartość,
-Content Masters,Mistrzowie treści,
-Content Type,Typ zawartości,
-Continue Configuration,Kontynuuj konfigurację,
-Contract,Kontrakt,
-Contract End Date must be greater than Date of Joining,Końcowa data kontraktu musi być większa od Daty Członkowstwa,
-Contribution %,Udział %,
-Contribution Amount,Kwota udziału,
-Conversion factor for default Unit of Measure must be 1 in row {0},Współczynnikiem konwersji dla domyślnej Jednostki Pomiaru musi być 1 w rzędzie {0},
-Conversion rate cannot be 0 or 1,Wartością konwersji nie może być 0 ani 1,
-Convert to Group,Przekształć w Grupę,
-Convert to Non-Group,Przekształć w nie-Grupę,
-Cosmetics,Kosmetyki,
-Cost Center,Centrum kosztów,
-Cost Center Number,Numer centrum kosztów,
-Cost Center and Budgeting,Centrum kosztów i budżetowanie,
-Cost Center is required in row {0} in Taxes table for type {1},,
-Cost Center with existing transactions can not be converted to group,Centrum Kosztów z istniejącą transakcją nie może być przekształcone w grupę,
-Cost Center with existing transactions can not be converted to ledger,Centrum Kosztów z istniejącą transakcją nie może być przekształcone w rejestr,
-Cost Centers,Centra Kosztów,
-Cost Updated,Koszt Zaktualizowano,
-Cost as on,Kosztować od,
-Cost of Delivered Items,Koszt dostarczonych przedmiotów,
-Cost of Goods Sold,Wartość sprzedanych pozycji w cenie nabycia,
-Cost of Issued Items,Koszt Emitowanych Przedmiotów,
-Cost of New Purchase,Koszt zakupu nowego,
-Cost of Purchased Items,Koszt zakupionych towarów,
-Cost of Scrapped Asset,Koszt złomowany aktywach,
-Cost of Sold Asset,Koszt sprzedanych aktywów,
-Cost of various activities,Koszt różnych działań,
-"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Nie można utworzyć noty kredytowej automatycznie, odznacz opcję &quot;Nota kredytowa&quot; i prześlij ponownie",
-Could not generate Secret,Nie można wygenerować Tajnego,
-Could not retrieve information for {0}.,Nie można pobrać informacji dla {0}.,
-Could not solve criteria score function for {0}. Make sure the formula is valid.,"Nie można rozwiązać funkcji punktacji kryterium dla {0}. Upewnij się, że formuła jest prawidłowa.",
-Could not solve weighted score function. Make sure the formula is valid.,"Nie udało się rozwiązać funkcji ważonych punktów. Upewnij się, że formuła jest prawidłowa.",
-Could not submit some Salary Slips,Nie można przesłać niektórych zwrotów wynagrodzeń,
-"Could not update stock, invoice contains drop shipping item.","Nie można zaktualizować stanu - faktura zawiera pozycję, której proces wysyłki scedowano na dostawcę.",
-Country wise default Address Templates,Szablony Adresów na dany kraj,
-Course,Kurs,
-Course Code: ,Kod kursu:,
-Course Enrollment {0} does not exists,Rejestracja kursu {0} nie istnieje,
-Course Schedule,Plan zajęć,
-Course: ,Kierunek:,
-Cr,Kr,
-Create,Utwórz,
-Create BOM,Utwórz zestawienie komponentów,
-Create Delivery Trip,Utwórz podróż dostawy,
-Create Disbursement Entry,Utwórz wpis wypłaty,
-Create Employee,Utwórz pracownika,
-Create Employee Records,Tworzenie pracownicze Records,
-"Create Employee records to manage leaves, expense claims and payroll","Tworzenie rekordów pracownika do zarządzania nieobecnościami, roszczenia o wydatkach i płac",
-Create Fee Schedule,Utwórz harmonogram opłat,
-Create Fees,Utwórz opłaty,
-Create Inter Company Journal Entry,Utwórz wpis do dziennika firmy,
-Create Invoice,Wystaw fakturę,
-Create Invoices,Utwórz faktury,
-Create Job Card,Utwórz kartę pracy,
-Create Journal Entry,Utwórz wpis do dziennika,
-Create Lead,Utwórz ołów,
-Create Leads,Tworzenie Leads,
-Create Maintenance Visit,Utwórz wizytę serwisową,
-Create Material Request,Utwórz żądanie materiałowe,
-Create Multiple,Utwórz wiele,
-Create Opening Sales and Purchase Invoices,Utwórz otwarcie sprzedaży i faktury zakupu,
-Create Payment Entries,Utwórz wpisy płatności,
-Create Payment Entry,Utwórz wpis płatności,
-Create Print Format,Tworzenie format wydruku,
-Create Purchase Order,Utwórz zamówienie zakupu,
-Create Purchase Orders,Stwórz zamówienie zakupu,
-Create Quotation,Utwórz ofertę,
-Create Salary Slip,Utwórz pasek wynagrodzenia,
-Create Salary Slips,Utwórz wynagrodzenie wynagrodzenia,
-Create Sales Invoice,Utwórz fakturę sprzedaży,
-Create Sales Order,Utwórz zamówienie sprzedaży,
-Create Sales Orders to help you plan your work and deliver on-time,"Twórz zlecenia sprzedaży, aby pomóc Ci zaplanować pracę i dostarczyć terminowość",
-Create Sample Retention Stock Entry,Utwórz wpis dotyczący przechowywania próbki,
-Create Student,Utwórz ucznia,
-Create Student Batch,Utwórz Partię Ucznia,
-Create Student Groups,Tworzenie grup studenckich,
-Create Supplier Quotation,Utwórz ofertę dla dostawców,
-Create Tax Template,Utwórz szablon podatku,
-Create Timesheet,Utwórz grafik,
-Create User,Stwórz użytkownika,
-Create Users,Tworzenie użytkowników,
-Create Variant,Utwórz wariant,
-Create Variants,Tworzenie Warianty,
-"Create and manage daily, weekly and monthly email digests.",,
-Create customer quotes,Tworzenie cytaty z klientami,
-Create rules to restrict transactions based on values.,,
-Created {0} scorecards for {1} between: ,Utworzono {0} karty wyników dla {1} między:,
-Creating Company and Importing Chart of Accounts,Tworzenie firmy i importowanie planu kont,
-Creating Fees,Tworzenie opłat,
-Creating Payment Entries......,Tworzenie wpisów płatności ......,
-Creating Salary Slips...,Tworzenie zarobków ...,
-Creating student groups,Tworzenie grup studentów,
-Creating {0} Invoice,Tworzenie faktury {0},
-Credit,,
-Credit ({0}),Kredyt ({0}),
-Credit Account,Konto kredytowe,
-Credit Balance,Saldo kredytowe,
-Credit Card,,
-Credit Days cannot be a negative number,Dni kredytu nie mogą być liczbą ujemną,
-Credit Limit,Limit kredytowy,
-Credit Note,Nota uznaniowa (kredytowa),
-Credit Note Amount,Kwota noty uznaniowej,
-Credit Note Issued,Credit blanco wystawiony,
-Credit Note {0} has been created automatically,Nota kredytowa {0} została utworzona automatycznie,
-Credit limit has been crossed for customer {0} ({1}/{2}),Limit kredytowy został przekroczony dla klienta {0} ({1} / {2}),
-Creditors,Wierzyciele,
-Criteria weights must add up to 100%,Kryteria wag muszą dodać do 100%,
-Crop Cycle,Crop Cycle,
-Crops & Lands,Uprawy i ziemie,
-Currency Exchange must be applicable for Buying or for Selling.,Wymiana walut musi dotyczyć Kupowania lub Sprzedaży.,
-Currency can not be changed after making entries using some other currency,Waluta nie może być zmieniony po dokonaniu wpisów używając innej walucie,
-Currency exchange rate master.,Główna wartość Wymiany walut,
-Currency for {0} must be {1},Waluta dla {0} musi być {1},
-Currency is required for Price List {0},Waluta jest wymagana dla Cenniku {0},
-Currency of the Closing Account must be {0},Waluta Rachunku Zamknięcie musi być {0},
-Currency of the price list {0} must be {1} or {2},Waluta listy cen {0} musi wynosić {1} lub {2},
-Currency should be same as Price List Currency: {0},"Waluta powinna być taka sama, jak waluta cennika: {0}",
-Current,Bieżący,
-Current Assets,Aktywa finansowe,
-Current BOM and New BOM can not be same,,
-Current Job Openings,Aktualne ofert pracy,
-Current Liabilities,Bieżące Zobowiązania,
-Current Qty,Obecna ilość,
-Current invoice {0} is missing,Brak aktualnej faktury {0},
-Custom HTML,Niestandardowy HTML,
-Custom?,Niestandardowy?,
-Customer,Klient,
-Customer Addresses And Contacts,,
-Customer Contact,Kontakt z klientem,
-Customer Database.,Baza danych klientów.,
-Customer Group,Grupa klientów,
-Customer LPO,Klient LPO,
-Customer LPO No.,Numer klienta LPO,
-Customer Name,Nazwa klienta,
-Customer POS Id,Identyfikator klienta klienta,
-Customer Service,Obsługa klienta,
-Customer and Supplier,Klient i dostawca,
-Customer is required,Klient jest wymagany,
-Customer isn't enrolled in any Loyalty Program,Klient nie jest zarejestrowany w żadnym Programie Lojalnościowym,
-Customer required for 'Customerwise Discount',,
-Customer {0} does not belong to project {1},Klient {0} nie należy do projektu {1},
-Customer {0} is created.,Utworzono klienta {0}.,
-Customers in Queue,Klienci w kolejce,
-Customize Homepage Sections,Dostosuj sekcje strony głównej,
-Customizing Forms,Dostosowywanie formularzy,
-Daily Project Summary for {0},Codzienne podsumowanie projektu dla {0},
-Daily Reminders,Codzienne przypomnienia,
-Daily Work Summary,Dziennie Podsumowanie zawodowe,
-Daily Work Summary Group,Codzienna grupa podsumowująca pracę,
-Data Import and Export,Import i eksport danych,
-Data Import and Settings,Import i ustawienia danych,
-Database of potential customers.,Baza danych potencjalnych klientów.,
-Date Format,Format daty,
-Date Of Retirement must be greater than Date of Joining,Data przejścia na emeryturę musi być większa niż Data wstąpienia,
-Date is repeated,Data jest powtórzona,
-Date of Birth,Data urodzenia,
-Date of Birth cannot be greater than today.,Data urodzenia nie może być większa niż data dzisiejsza.,
-Date of Commencement should be greater than Date of Incorporation,Data rozpoczęcia powinna być większa niż data założenia,
-Date of Joining,Data Wstąpienia,
-Date of Joining must be greater than Date of Birth,Data Wstąpienie musi być większa niż Data Urodzenia,
-Date of Transaction,Data transakcji,
-Datetime,Data-czas,
-Day,Dzień,
-Debit,Debet,
-Debit ({0}),Debet ({0}),
-Debit A/C Number,Numer A / C debetu,
-Debit Account,Konto debetowe,
-Debit Note,Nota debetowa,
-Debit Note Amount,Kwota noty debetowej,
-Debit Note Issued,Nocie debetowej,
-Debit To is required,Debetowane Konto jest wymagane,
-Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debetowe i kredytowe nie równe dla {0} # {1}. Różnica jest {2}.,
-Debtors,Dłużnicy,
-Debtors ({0}),Dłużnicy ({0}),
-Declare Lost,Zadeklaruj Zagubiony,
-Deduction,Odliczenie,
-Default Activity Cost exists for Activity Type - {0},Istnieje Domyślnie aktywny Koszt rodzajów działalności - {0},
-Default BOM ({0}) must be active for this item or its template,Domyślnie Wykaz Materiałów ({0}) musi być aktywny dla tej pozycji lub jej szablonu,
-Default BOM for {0} not found,Domyślnie BOM dla {0} Nie znaleziono,
-Default BOM not found for Item {0} and Project {1},Domyślnie nie znaleziono elementu BOM dla elementu {0} i projektu {1},
-Default Letter Head,Domyślny nagłówek pisma,
-Default Tax Template,Domyślny szablon podatkowy,
-Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Domyślnie Jednostka miary dla pozycji {0} nie może być zmieniana bezpośrednio, ponieważ masz już jakąś transakcję (y) z innym UOM. Musisz utworzyć nowy obiekt, aby użyć innego domyślnego UOM.",
-Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',"Domyślne jednostki miary dla wariantu &quot;{0}&quot; musi być taki sam, jak w szablonie &#39;{1}&#39;",
-Default settings for buying transactions.,Domyślne ustawienia dla transakcji kupna,
-Default settings for selling transactions.,Domyślne ustawienia dla transakcji sprzedaży,
-Default tax templates for sales and purchase are created.,Definiowane są domyślne szablony podatkowe dla sprzedaży i zakupu.,
-Defaults,Wartości domyślne,
-Defense,Obrona,
-Define Project type.,Zdefiniuj typ projektu.,
-Define budget for a financial year.,Definiowanie budżetu za dany rok budżetowy.,
-Define various loan types,Definiować różne rodzaje kredytów,
-Del,Del,
-Delay in payment (Days),Opóźnienie w płatności (dni),
-Delete all the Transactions for this Company,"Usuń wszystkie transakcje, dla tej firmy",
-Deletion is not permitted for country {0},Usunięcie jest niedozwolone w przypadku kraju {0},
-Delivered,Dostarczono,
-Delivered Amount,Dostarczone Ilość,
-Delivered Qty,Dostarczona Liczba jednostek,
-Delivered: {0},Dostarczone: {0},
-Delivery,Dostarczanie,
-Delivery Date,Data dostawy,
-Delivery Note,Dowód dostawy,
-Delivery Note {0} is not submitted,Dowód dostawy {0} nie został wysłany,
-Delivery Note {0} must not be submitted,Dowód dostawy {0} nie może być wysłany,
-Delivery Notes {0} must be cancelled before cancelling this Sales Order,Dowody Dostawy {0} muszą być anulowane przed anulowanie Zamówienia Sprzedaży,
-Delivery Notes {0} updated,Zaktualizowano uwagi dotyczące dostawy {0},
-Delivery Status,Status dostawy,
-Delivery Trip,Podróż dostawy,
-Delivery warehouse required for stock item {0},Dostawa wymagane dla magazynu pozycji magazynie {0},
-Department,Departament,
-Department Stores,,
-Depreciation,Amortyzacja,
-Depreciation Amount,Kwota amortyzacji,
-Depreciation Amount during the period,Kwota amortyzacji w okresie,
-Depreciation Date,amortyzacja Data,
-Depreciation Eliminated due to disposal of assets,Amortyzacja Wyeliminowany z tytułu zbycia aktywów,
-Depreciation Entry,Amortyzacja,
-Depreciation Method,Metoda amortyzacji,
-Depreciation Row {0}: Depreciation Start Date is entered as past date,Wiersz amortyzacji {0}: Data rozpoczęcia amortyzacji jest wprowadzana jako data przeszła,
-Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Wiersz amortyzacji {0}: oczekiwana wartość po okresie użyteczności musi być większa lub równa {1},
-Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Wiersz amortyzacji {0}: Data następnej amortyzacji nie może być wcześniejsza niż data przydatności do użycia,
-Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Wiersz amortyzacji {0}: Data następnej amortyzacji nie może być wcześniejsza niż Data zakupu,
-Designer,Projektant,
-Detailed Reason,Szczegółowy powód,
-Details,Szczegóły,
-Details of Outward Supplies and inward supplies liable to reverse charge,Szczegóły dotyczące dostaw zewnętrznych i dostaw wewnętrznych podlegających zwrotnemu obciążeniu,
-Details of the operations carried out.,Szczegóły dotyczące przeprowadzonych operacji.,
-Diagnosis,Diagnoza,
-Did not find any item called {0},Nie znaleziono żadnych pozycji o nazwie {0},
-Diff Qty,Diff Qty,
-Difference Account,Konto Różnic,
-"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Konto różnica musi być kontem typu aktywami / pasywami, ponieważ Zdjęcie Pojednanie jest Wejście otwarcia",
-Difference Amount,Kwota różnicy,
-Difference Amount must be zero,Różnica Kwota musi wynosić zero,
-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.,,
-Direct Expenses,Wydatki bezpośrednie,
-Direct Income,Przychody bezpośrednie,
-Disable,Wyłącz,
-Disabled template must not be default template,Szablon niepełnosprawnych nie może być domyślny szablon,
-Disburse Loan,Wypłata pożyczki,
-Disbursed,Wypłacony,
-Disc,Dysk,
-Discharge,Rozładować się,
-Discount,Zniżka (rabat),
-Discount Percentage can be applied either against a Price List or for all Price List.,Rabat procentowy może być stosowany zarówno przed cenniku dla wszystkich Cenniku.,
-Discount must be less than 100,Zniżka musi wynosić mniej niż 100,
-Diseases & Fertilizers,Choroby i nawozy,
-Dispatch,Wyślij,
-Dispatch Notification,Powiadomienie o wysyłce,
-Dispatch State,Państwo wysyłki,
-Distance,Dystans,
-Distribution,Dystrybucja,
-Distributor,Dystrybutor,
-Dividends Paid,Dywidendy wypłacone,
-Do you really want to restore this scrapped asset?,Czy na pewno chcesz przywrócić złomowane atut?,
-Do you really want to scrap this asset?,Czy naprawdę chcemy zlikwidować ten atut?,
-Do you want to notify all the customers by email?,Czy chcesz powiadomić wszystkich klientów pocztą e-mail?,
-Doc Date,Doc Data,
-Doc Name,Doc Name,
-Doc Type,Doc Type,
-Docs Search,Wyszukiwanie dokumentów,
-Document Name,Nazwa dokumentu,
-Document Status,Stan dokumentu,
-Document Type,Typ Dokumentu,
-Domain,Domena,
-Domains,Domeny,
-Done,Gotowe,
-Donor,Dawca,
-Donor Type information.,Informacje o typie dawcy.,
-Donor information.,Informacje o dawcy.,
-Download JSON,Pobierz JSON,
-Draft,Wersja robocza,
-Drop Ship,Drop Ship,
-Drug,Narkotyk,
-Due / Reference Date cannot be after {0},Data referencyjne / Termin nie może być po {0},
-Due Date cannot be before Posting / Supplier Invoice Date,"Data ""do"" nie może być przed datą faktury Opublikowania / Dostawcy",
-Due Date is mandatory,Due Date jest obowiązkowe,
-Duplicate Entry. Please check Authorization Rule {0},Wpis zduplikowany. Proszę sprawdzić zasadę autoryzacji {0},
-Duplicate Serial No entered for Item {0},Zduplikowany Nr Seryjny wprowadzony dla przedmiotu {0},
-Duplicate customer group found in the cutomer group table,Duplikat grupa klientów znajduje się w tabeli grupy cutomer,
-Duplicate entry,Wpis zduplikowany,
-Duplicate item group found in the item group table,Duplikat grupę pozycji w tabeli grupy produktów,
-Duplicate roll number for student {0},Duplikat numeru rolki dla ucznia {0},
-Duplicate row {0} with same {1},Wiersz zduplikowany {0} z tym samym {1},
-Duplicate {0} found in the table,Duplikat {0} znaleziony w tabeli,
-Duration in Days,Czas trwania w dniach,
-Duties and Taxes,Podatki i cła,
-E-Invoicing Information Missing,Brak informacji o e-fakturowaniu,
-ERPNext Demo,ERPNext Demo,
-ERPNext Settings,Ustawienia ERPNext,
-Earliest,Najwcześniejszy,
-Earnest Money,Pieniądze zaliczkowe,
-Earning,Dochód,
-Edit,Edytować,
-Edit Publishing Details,Edytuj szczegóły publikowania,
-"Edit in full page for more options like assets, serial nos, batches etc.","Edytuj na całej stronie, aby uzyskać więcej opcji, takich jak zasoby, numery seryjne, partie itp.",
-Education,Edukacja,
-Either location or employee must be required,Każda lokalizacja lub pracownik muszą być wymagane,
-Either target qty or target amount is mandatory,Wymagana jest ilość lub kwota docelowa,
-Either target qty or target amount is mandatory.,Wymagana jest ilość lub kwota docelowa,
-Electrical,Elektryczne,
-Electronic Equipments,Urządzenia elektroniczne,
-Electronics,Elektronika,
-Eligible ITC,Kwalifikujące się ITC,
-Email Account,Konto e-mail,
-Email Address,Adres e-mail,
-"Email Address must be unique, already exists for {0}","E-mail musi być unikalny, istnieje już dla {0}",
-Email Digest: ,przetwarzanie maila,
-Email Reminders will be sent to all parties with email contacts,Przypomnienia e-mailem będą wysyłane do wszystkich stron z kontaktami e-mail,
-Email Sent,Wiadomość wysłana,
-Email Template,Szablon e-maila,
-Email not found in default contact,Nie znaleziono wiadomości e-mail w domyślnym kontakcie,
-Email sent to {0},Wiadomość wysłana do {0},
-Employee,Pracownik,
-Employee A/C Number,Numer A / C pracownika,
-Employee Advances,Zaliczki dla pracowników,
-Employee Benefits,Świadczenia pracownicze,
-Employee Grade,Klasa pracownika,
-Employee ID,numer identyfikacyjny pracownika,
-Employee Lifecycle,Cykl życia pracownika,
-Employee Name,Nazwisko pracownika,
-Employee Promotion cannot be submitted before Promotion Date ,Promocji Pracowników nie można przesłać przed datą promocji,
-Employee Referral,Referencje pracownika,
-Employee Transfer cannot be submitted before Transfer Date ,Przeniesienie pracownika nie może zostać przesłane przed datą transferu,
-Employee cannot report to himself.,Pracownik nie może odpowiadać do samego siebie.,
-Employee relieved on {0} must be set as 'Left',pracownik zwalnia się na {0} musi być ustawiony jako 'opuścił',
-Employee {0} already submited an apllication {1} for the payroll period {2},Pracownik {0} przesłał już aplikację {1} na okres rozliczeniowy {2},
-Employee {0} has already applied for {1} between {2} and {3} : ,Pracownik {0} złożył już wniosek o przyznanie {1} między {2} a {3}:,
-Employee {0} has no maximum benefit amount,Pracownik {0} nie ma maksymalnej kwoty świadczenia,
-Employee {0} is not active or does not exist,Pracownik {0} jest nieaktywny lub nie istnieje,
-Employee {0} is on Leave on {1},Pracownik {0} jest Nieobecny w trybie {1},
-Employee {0} of grade {1} have no default leave policy,Pracownik {0} stopnia {1} nie ma domyślnych zasad dotyczących urlopu,
-Employee {0} on Half day on {1},Pracownik {0} na pół dnia na {1},
-Enable,Włączyć,
-Enable / disable currencies.,Włącz/wyłącz waluty.,
-Enabled,Aktywny,
-"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Włączenie &quot;użycie do koszyka&quot;, ponieważ koszyk jest włączony i nie powinno być co najmniej jedna zasada podatkowa w koszyku",
-End Date,Data zakonczenia,
-End Date can not be less than Start Date,Data zakończenia nie może być krótsza niż data rozpoczęcia,
-End Date cannot be before Start Date.,Data zakończenia nie może być wcześniejsza niż data rozpoczęcia.,
-End Year,Koniec roku,
-End Year cannot be before Start Year,Koniec roku nie może być przed rozpoczęciem Roku,
-End on,Podłużnie,
-End time cannot be before start time,Czas zakończenia nie może być wcześniejszy niż czas rozpoczęcia,
-Ends On date cannot be before Next Contact Date.,Kończy się Data nie może być wcześniejsza niż data następnego kontaktu.,
-Energy,Energia,
-Engineer,Inżynier,
-Enough Parts to Build,Wystarczające elementy do budowy,
-Enroll,Zapisać,
-Enrolling student,Zapis uczeń,
-Enrolling students,Zapisywanie studentów,
-Enter depreciation details,Wprowadź szczegóły dotyczące amortyzacji,
-Enter the Bank Guarantee Number before submittting.,Wprowadź numer gwarancyjny banku przed złożeniem wniosku.,
-Enter the name of the Beneficiary before submittting.,Wprowadź nazwę Beneficjenta przed złożeniem wniosku.,
-Enter the name of the bank or lending institution before submittting.,Wprowadź nazwę banku lub instytucji kredytowej przed złożeniem wniosku.,
-Enter value betweeen {0} and {1},Wpisz wartość między {0} a {1},
-Entertainment & Leisure,Rozrywka i relaks,
-Entertainment Expenses,Wydatki na reprezentację,
-Equity,Kapitał własny,
-Error Log,Dziennik błędów,
-Error evaluating the criteria formula,Błąd podczas oceny formuły kryterium,
-Error in formula or condition: {0},Błąd wzoru lub stanu {0},
-Error: Not a valid id?,Błąd: Nie ważne id?,
-Estimated Cost,Szacowany koszt,
-Evaluation,Ocena,
-"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Nawet jeśli istnieje wiele przepisów dotyczących cen o najwyższym priorytecie, a następnie następujące priorytety wewnętrznej są stosowane:",
-Event,Wydarzenie,
-Event Location,Lokalizacja wydarzenia,
-Event Name,Nazwa wydarzenia,
-Exchange Gain/Loss,Wymiana Zysk / Strata,
-Exchange Rate Revaluation master.,Mistrz wyceny kursu wymiany.,
-Exchange Rate must be same as {0} {1} ({2}),"Kurs wymiany muszą być takie same, jak {0} {1} ({2})",
-Excise Invoice,Akcyza Faktura,
-Execution,Wykonanie,
-Executive Search,Szukanie wykonawcze,
-Expand All,Rozwiń wszystkie,
-Expected Delivery Date,Spodziewana data odbioru przesyłki,
-Expected Delivery Date should be after Sales Order Date,Oczekiwana data dostarczenia powinna nastąpić po Dacie Zamówienia Sprzedaży,
-Expected End Date,Spodziewana data końcowa,
-Expected Hrs,Oczekiwany godz,
-Expected Start Date,Spodziewana data startowa,
-Expense,Koszt,
-Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Konto koszty / Różnica ({0}) musi być kontem ""rachunek zysków i strat""",
-Expense Account,Konto Wydatków,
-Expense Claim,Zwrot kosztów,
-Expense Claim for Vehicle Log {0},Koszty Żądanie Vehicle Zaloguj {0},
-Expense Claim {0} already exists for the Vehicle Log,Koszty roszczenie {0} już istnieje dla Zaloguj Pojazdów,
-Expense Claims,Zapotrzebowania na wydatki,
-Expense account is mandatory for item {0},Konto wydatków jest obowiązkowe dla przedmiotu {0},
-Expenses,Wydatki,
-Expenses Included In Asset Valuation,Koszty uwzględnione w wycenie aktywów,
-Expenses Included In Valuation,Zaksięgowane wydatki w wycenie,
-Expired Batches,Wygasłe partie,
-Expires On,Upływa w dniu,
-Expiring On,Wygasający,
-Expiry (In Days),Wygaśnięcie (w dniach),
-Explore,Przeglądaj,
-Export E-Invoices,Eksportuj e-faktury,
-Extra Large,Bardzo duży,
-Extra Small,Extra Small,
-Fail,Zawieść,
-Failed,Nieudane,
-Failed to create website,Nie udało się utworzyć witryny,
-Failed to install presets,Nie udało się zainstalować ustawień wstępnych,
-Failed to login,Nie udało się zalogować,
-Failed to setup company,Nie udało się skonfigurować firmy,
-Failed to setup defaults,Nie udało się skonfigurować ustawień domyślnych,
-Failed to setup post company fixtures,Nie udało się skonfigurować urządzeń firm post,
-Fax,Faks,
-Fee,Opłata,
-Fee Created,Opłata utworzona,
-Fee Creation Failed,Utworzenie opłaty nie powiodło się,
-Fee Creation Pending,Tworzenie opłat w toku,
-Fee Records Created - {0},Utworzono Records Fee - {0},
-Feedback,Informacja zwrotna,
-Fees,Opłaty,
-Female,Kobieta,
-Fetch Data,Pobierz dane,
-Fetch Subscription Updates,Pobierz aktualizacje subskrypcji,
-Fetch exploded BOM (including sub-assemblies),,
-Fetching records......,Pobieranie rekordów ......,
-Field Name,Nazwa pola,
-Fieldname,Nazwa pola,
-Fields,Pola,
-Fill the form and save it,Wypełnij formularz i zapisz,
-Filter Employees By (Optional),Filtruj pracowników według (opcjonalnie),
-"Filter Fields Row #{0}: Fieldname <b>{1}</b> must be of type ""Link"" or ""Table MultiSelect""",Filtruj pola Wiersz # {0}: Nazwa pola <b>{1}</b> musi być typu „Link” lub „Tabela MultiSelect”,
-Filter Total Zero Qty,Filtruj całkowitą liczbę zerową,
-Finance Book,Książka finansowa,
-Financial / accounting year.,Rok finansowy / księgowy.,
-Financial Services,Usługi finansowe,
-Financial Statements,Sprawozdania finansowe,
-Financial Year,Rok budżetowy,
-Finish,koniec,
-Finished Good,Skończony dobrze,
-Finished Good Item Code,Gotowy kod dobrego towaru,
-Finished Goods,Ukończone dobra,
-Finished Item {0} must be entered for Manufacture type entry,Zakończone Pozycja {0} musi być wprowadzony do wejścia typu Produkcja,
-Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Ilość gotowego produktu <b>{0}</b> i ilość <b>{1}</b> nie mogą się różnić,
-First Name,Imię,
-"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","System fiskalny jest obowiązkowy, uprzejmie ustal system podatkowy w firmie {0}",
-Fiscal Year,Rok podatkowy,
-Fiscal Year End Date should be one year after Fiscal Year Start Date,Data zakończenia roku obrachunkowego powinna wynosić jeden rok od daty rozpoczęcia roku obrachunkowego,
-Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Rok obrotowy Data rozpoczęcia i Data zakończenia roku obrotowego są już ustawione w roku podatkowym {0},
-Fiscal Year Start Date should be one year earlier than Fiscal Year End Date,Data rozpoczęcia roku podatkowego powinna być o rok wcześniejsza niż data zakończenia roku obrotowego,
-Fiscal Year {0} does not exist,Rok fiskalny {0} nie istnieje,
-Fiscal Year {0} is required,Rok fiskalny {0} jest wymagane,
-Fiscal Year {0} not found,Rok fiskalny {0} Nie znaleziono,
-Fixed Asset,Trwała własność,
-Fixed Asset Item must be a non-stock item.,Trwałego Rzecz musi być element non-stock.,
-Fixed Assets,Środki trwałe,
-Following Material Requests have been raised automatically based on Item's re-order level,Niniejszy materiał Wnioski zostały podniesione automatycznie na podstawie poziomu ponownego zamówienia elementu,
-Following accounts might be selected in GST Settings:,W ustawieniach GST można wybrać następujące konta:,
-Following course schedules were created,Utworzono harmonogramy kursów,
-Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Poniższy element {0} nie jest oznaczony jako element {1}. Możesz je włączyć jako element {1} z jego wzorca pozycji,
-Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,Następujące elementy {0} nie są oznaczone jako {1}. Możesz je włączyć jako element {1} z jego wzorca pozycji,
-Food,Żywność,
-"Food, Beverage & Tobacco","Żywność, Trunki i Tytoń",
-For,Dla,
-"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Dla pozycji &quot;Produkt Bundle&quot;, magazyn, nr seryjny i numer partii będą rozpatrywane z &quot;packing list&quot; tabeli. Jeśli magazynowe oraz Batch Nie są takie same dla wszystkich elementów Opakowanie do pozycji każdego &quot;produkt Bundle&quot;, wartości te mogą zostać wpisane do tabeli głównej pozycji, wartości zostaną skopiowane do &quot;packing list&quot; tabeli.",
-For Employee,Dla pracownika,
-For Quantity (Manufactured Qty) is mandatory,Do Ilość (Wyprodukowano kopie) są obowiązkowe,
-For Supplier,Dla dostawcy,
-For Warehouse,Dla magazynu,
-For Warehouse is required before Submit,Dla magazynu jest wymagane przed wysłaniem,
-"For an item {0}, quantity must be negative number",W przypadku elementu {0} ilość musi być liczbą ujemną,
-"For an item {0}, quantity must be positive number",W przypadku elementu {0} liczba musi być liczbą dodatnią,
-"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",W przypadku karty pracy {0} można dokonać tylko wpisu typu „Transfer materiałów do produkcji”,
-"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Do rzędu {0} w {1}. Aby dołączyć {2} w cenę towaru, wiersze {3} musi być włączone",
-For row {0}: Enter Planned Qty,Dla wiersza {0}: wpisz planowaną liczbę,
-"For {0}, only credit accounts can be linked against another debit entry","Dla {0}, tylko Kredytowane konta mogą być połączone z innym zapisem po stronie debetowej",
-"For {0}, only debit accounts can be linked against another credit entry","Dla {0}, tylko rachunki płatnicze mogą być połączone z innym wejściem kredytową",
-Forum Activity,Aktywność na forum,
-Free item code is not selected,Kod wolnego przedmiotu nie jest wybrany,
-Freight and Forwarding Charges,Koszty dostaw i przesyłek,
-Frequency,Częstotliwość,
-Friday,Piątek,
-From,Od,
-From Address 1,Od adresu 1,
-From Address 2,Od adresu 2,
-From Currency and To Currency cannot be same,Od Waluty i Do Waluty nie mogą być te same,
-From Date and To Date lie in different Fiscal Year,Od daty i daty są różne w danym roku obrotowym,
-From Date cannot be greater than To Date,Data od - nie może być późniejsza niż Data do,
-From Date must be before To Date,Data od musi być przed datą do,
-From Date should be within the Fiscal Year. Assuming From Date = {0},"""Data od"" powinna być w tym roku podatkowym. Przyjmując Datę od = {0}",
-From Date {0} cannot be after employee's relieving Date {1},Od daty {0} nie może być po zwolnieniu pracownika Data {1},
-From Date {0} cannot be before employee's joining Date {1},Od daty {0} nie może upłynąć data dołączenia pracownika {1},
-From Datetime,Od DateTime,
-From Delivery Note,Od dowodu dostawy,
-From Fiscal Year,Od roku obrotowego,
-From GSTIN,Z GSTIN,
-From Party Name,Od nazwy imprezy,
-From Pin Code,Z kodu PIN,
-From Place,Z miejsca,
-From Range has to be less than To Range,Od Zakres musi być mniejsza niż do zakresu,
-From State,Z państwa,
-From Time,Od czasu,
-From Time Should Be Less Than To Time,Od czasu powinno być mniej niż w czasie,
-From Time cannot be greater than To Time.,Od czasu nie może być większa niż do czasu.,
-"From a supplier under composition scheme, Exempt and Nil rated","Od dostawcy w ramach systemu składu, Zwolniony i Nil oceniono",
-From and To dates required,Daty Od i Do są wymagane,
-From date can not be less than employee's joining date,Od daty nie może być mniejsza niż data dołączenia pracownika,
-From value must be less than to value in row {0},"Wartość ""od"" musi być mniejsza niż wartość w rzędzie {0}",
-From {0} | {1} {2},Od {0} | {1} {2},
-Fuel Price,Cena paliwa,
-Fuel Qty,Ilość paliwa,
-Fulfillment,Spełnienie,
-Full,Pełny,
-Full Name,Imię i nazwisko,
-Full-time,Na cały etet,
-Fully Depreciated,pełni zamortyzowanych,
-Furnitures and Fixtures,Meble i wyposażenie,
-"Further accounts can be made under Groups, but entries can be made against non-Groups","Dalsze relacje mogą być wykonane w ramach grup, ale wpisy mogą być wykonane przed spoza grup",
-Further cost centers can be made under Groups but entries can be made against non-Groups,"Kolejne centra kosztów mogą być wykonane w ramach grup, ale wpisy mogą być wykonane przed spoza grup",
-Further nodes can be only created under 'Group' type nodes,"Kolejne powiązania mogą być tworzone tylko w powiązaniach typu ""grupa""",
-Future dates not allowed,Przyszłe daty są niedozwolone,
-GSTIN,GSTIN,
-GSTR3B-Form,Formularz GSTR3B,
-Gain/Loss on Asset Disposal,Zysk / Strata na Aktywów pozbywaniu,
-Gantt Chart,Wykres Gantta,
-Gantt chart of all tasks.,Wykres Gantta dla wszystkich zadań.,
-Gender,Płeć,
-General,Ogólne,
-General Ledger,Księga Główna,
-Generate Material Requests (MRP) and Work Orders.,Generuj zapotrzebowanie materiałowe (MRP) i zlecenia pracy.,
-Generate Secret,Generuj sekret,
-Get Details From Declaration,Uzyskaj szczegółowe informacje z deklaracji,
-Get Employees,Zdobądź pracowników,
-Get Invocies,Zdobądź Invocies,
-Get Invoices,Uzyskaj faktury,
-Get Invoices based on Filters,Uzyskaj faktury na podstawie filtrów,
-Get Items from BOM,Weź produkty z zestawienia materiałowego,
-Get Items from Healthcare Services,Pobierz przedmioty z usług opieki zdrowotnej,
-Get Items from Prescriptions,Zdobądź przedmioty z recept,
-Get Items from Product Bundle,Elementy z Bundle produktu,
-Get Suppliers,Dodaj dostawców,
-Get Suppliers By,Dodaj dostawców wg,
-Get Updates,Informuj o aktualizacjach,
-Get customers from,Zdobądź klientów,
-Get from Patient Encounter,Uzyskaj od Spotkania Pacjenta,
-Getting Started,Start,
-GitHub Sync ID,GitHub Sync ID,
-Global settings for all manufacturing processes.,Globalne ustawienia dla wszystkich procesów produkcyjnych.,
-Go to the Desktop and start using ERPNext,Przejdź do pulpitu i rozpocząć korzystanie ERPNext,
-GoCardless SEPA Mandate,Mandat SEPA bez karty,
-GoCardless payment gateway settings,Ustawienia bramy płatności bez płatności,
-Goal and Procedure,Cel i procedura,
-Goals cannot be empty,Cele nie mogą być puste,
-Goods In Transit,Towary w tranzycie,
-Goods Transferred,Przesyłane towary,
-Goods and Services Tax (GST India),Podatek od towarów i usług (GST India),
-Goods are already received against the outward entry {0},Towary są już otrzymane w stosunku do wpisu zewnętrznego {0},
-Government,Rząd,
-Grand Total,Suma Całkowita,
-Grant,Dotacja,
-Grant Application,Wniosek o dofinansowanie,
-Grant Leaves,Przydziel możliwe Nieobecności,
-Grant information.,Udziel informacji.,
-Grocery,Artykuły spożywcze,
-Gross Pay,Płaca brutto,
-Gross Profit,Zysk brutto,
-Gross Profit %,Zysk brutto%,
-Gross Profit / Loss,Zysk / Strata,
-Gross Purchase Amount,Zakup Kwota brutto,
-Gross Purchase Amount is mandatory,Zakup Kwota brutto jest obowiązkowe,
-Group by Account,Grupuj według konta,
-Group by Party,Grupa według partii,
-Group by Voucher,Grupuj według Podstawy księgowania,
-Group by Voucher (Consolidated),Group by Voucher (Consolidated),
-Group node warehouse is not allowed to select for transactions,"Magazyn węzeł Grupa nie jest dozwolone, aby wybrać dla transakcji",
-Group to Non-Group,Grupa do Non-Group,
-Group your students in batches,Grupa uczniowie w partiach,
-Groups,Grupy,
-Guardian1 Email ID,Identyfikator e-maila Guardian1,
-Guardian1 Mobile No,Guardian1 Komórka Nie,
-Guardian1 Name,Nazwa Guardian1,
-Guardian2 Email ID,Identyfikator e-mail Guardian2,
-Guardian2 Mobile No,Guardian2 Komórka Nie,
-Guardian2 Name,Nazwa Guardian2,
-Guest,Gość,
-HR Manager,Kierownik ds. Personalnych,
-HSN,HSN,
-HSN/SAC,HSN / SAC,
-Half Day,Pół Dnia,
-Half Day Date is mandatory,Data półdniowa jest obowiązkowa,
-Half Day Date should be between From Date and To Date,Pół Dzień Data powinna być pomiędzy Od Data i do tej pory,
-Half Day Date should be in between Work From Date and Work End Date,Data pół dnia powinna znajdować się pomiędzy datą pracy a datą zakończenia pracy,
-Half Yearly,Pół Roku,
-Half day date should be in between from date and to date,Data pół dnia powinna być pomiędzy datą i datą,
-Half-Yearly,Półroczny,
-Hardware,Sprzęt komputerowy,
-Head of Marketing and Sales,Kierownik marketingu i sprzedaży,
-Health Care,Opieka zdrowotna,
-Healthcare,Opieka zdrowotna,
-Healthcare (beta),Opieka zdrowotna (beta),
-Healthcare Practitioner,Praktyk opieki zdrowotnej,
-Healthcare Practitioner not available on {0},Pracownik służby zdrowia niedostępny na {0},
-Healthcare Practitioner {0} not available on {1},Pracownik służby zdrowia {0} nie jest dostępny w {1},
-Healthcare Service Unit,Jednostka opieki zdrowotnej,
-Healthcare Service Unit Tree,Drzewo usług opieki zdrowotnej,
-Healthcare Service Unit Type,Rodzaj usługi opieki zdrowotnej,
-Healthcare Services,Opieka zdrowotna,
-Healthcare Settings,Ustawienia opieki zdrowotnej,
-Hello,cześć,
-Help Results for,Pomoc Wyniki dla,
-High,Wysoki,
-High Sensitivity,Wysoka czułość,
-Hold,Trzymaj,
-Hold Invoice,Hold Invoice,
-Holiday,Święto,
-Holiday List,Lista Świąt,
-Hotel Rooms of type {0} are unavailable on {1},Pokoje hotelowe typu {0} są niedostępne w dniu {1},
-Hotels,Hotele,
-Hourly,Cogodzinny,
-Hours,godziny,
-House rent paid days overlapping with {0},Dni płatne za wynajem domu pokrywają się z {0},
-House rented dates required for exemption calculation,Daty wynajmu domu wymagane do obliczenia odstępstwa,
-House rented dates should be atleast 15 days apart,Terminy wynajmu domu powinny wynosić co najmniej 15 dni,
-How Pricing Rule is applied?,Jak reguła jest stosowana Wycena?,
-Hub Category,Kategoria koncentratora,
-Hub Sync ID,Identyfikator Hub Sync,
-Human Resource,Zasoby ludzkie,
-Human Resources,Kadry,
-IFSC Code,Kod IFSC,
-IGST Amount,Wielkość IGST,
-IP Address,Adres IP,
-ITC Available (whether in full op part),Dostępne ITC (czy w pełnej wersji),
-ITC Reversed,Odwrócono ITC,
-Identifying Decision Makers,Identyfikacja decydentów,
-"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)","Jeśli zaznaczona jest opcja automatycznego wyboru, klienci zostaną automatycznie połączeni z danym Programem lojalnościowym (przy zapisie)",
-"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Jeśli wiele Zasady ustalania cen nadal dominować, użytkownicy proszeni są o ustawienie Priorytet ręcznie rozwiązać konflikt.",
-"If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Jeśli wybrana zostanie reguła cenowa dla &quot;Stawka&quot;, nadpisze ona Cennik. Stawka za ustalanie stawek jest ostateczną stawką, więc nie należy stosować dodatkowej zniżki. W związku z tym w transakcjach takich jak zamówienie sprzedaży, zamówienie itp. Zostanie ono pobrane w polu &quot;stawka&quot;, a nie w polu &quot;cennik ofert&quot;.",
-"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.","Jeśli dwóch lub więcej Zasady ustalania cen na podstawie powyższych warunków, jest stosowana Priorytet. Priorytetem jest liczba z zakresu od 0 do 20, podczas gdy wartość domyślna wynosi zero (puste). Wyższa liczba oznacza, że będzie mieć pierwszeństwo, jeśli istnieje wiele przepisów dotyczących cen z samych warunkach.",
-"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.",W przypadku nielimitowanego wygaśnięcia punktów lojalnościowych czas trwania ważności jest pusty lub 0.,
-"If you have any questions, please get back to us.","Jeśli masz jakieś pytania, proszę wrócić do nas.",
-Ignore Existing Ordered Qty,Ignoruj istniejącą zamówioną ilość,
-Image,Obrazek,
-Image View,Widok obrazka,
-Import Data,Importuj dane,
-Import Day Book Data,Importuj dane książki dziennej,
-Import Log,Log operacji importu,
-Import Master Data,Importuj dane podstawowe,
-Import in Bulk,Masowego importu,
-Import of goods,Import towarów,
-Import of services,Import usług,
-Importing Items and UOMs,Importowanie elementów i UOM,
-Importing Parties and Addresses,Importowanie stron i adresów,
-In Maintenance,W naprawie,
-In Production,W produkcji,
-In Qty,W ilości,
-In Stock Qty,Ilość w magazynie,
-In Stock: ,W magazynie:,
-In Value,w polu Wartość,
-"In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent","W przypadku programu wielowarstwowego Klienci zostaną automatycznie przypisani do danego poziomu, zgodnie z wydatkami",
-Inactive,Nieaktywny,
-Incentives,,
-Include Default Book Entries,Dołącz domyślne wpisy książki,
-Include Exploded Items,Dołącz rozstrzelone przedmioty,
-Include POS Transactions,Uwzględnij transakcje POS,
-Include UOM,Dołącz UOM,
-Included in Gross Profit,Zawarte w zysku brutto,
-Income,Przychody,
-Income Account,Konto przychodów,
-Income Tax,Podatek dochodowy,
-Incoming,Przychodzące,
-Incoming Rate,,
-Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Nieprawidłowa liczba zapisów w Księdze głównej. Być może wybrano niewłaściwe konto w transakcji.,
-Increment cannot be 0,Przyrost nie może być 0,
-Increment for Attribute {0} cannot be 0,Przyrost dla atrybutu {0} nie może być 0,
-Indirect Expenses,Wydatki pośrednie,
-Indirect Income,Przychody pośrednie,
-Individual,Indywidualny,
-Ineligible ITC,Niekwalifikowany ITC,
-Initiated,Zapoczątkowany,
-Inpatient Record,Zapis ambulatoryjny,
-Insert,Wstaw,
-Installation Note,Notka instalacyjna,
-Installation Note {0} has already been submitted,Notka instalacyjna {0} została już dodana,
-Installation date cannot be before delivery date for Item {0},Data instalacji nie może być wcześniejsza niż data dostawy dla pozycji {0},
-Installing presets,Instalowanie ustawień wstępnych,
-Institute Abbreviation,Instytut Skrót,
-Institute Name,Nazwa Instytutu,
-Instructor,Instruktor,
-Insufficient Stock,Niewystarczający zapas,
-Insurance Start date should be less than Insurance End date,Data rozpoczęcia ubezpieczenia powinna być mniejsza niż data zakończenia ubezpieczenia,
-Integrated Tax,Zintegrowany podatek,
-Inter-State Supplies,Dostawy międzypaństwowe,
-Interest Amount,Kwota procentowa,
-Interests,Zainteresowania,
-Intern,Stażysta,
-Internet Publishing,Wydawnictwa internetowe,
-Intra-State Supplies,Materiały wewnątrzpaństwowe,
-Introduction,Wprowadzenie,
-Invalid Attribute,Nieprawidłowy atrybut,
-Invalid Blanket Order for the selected Customer and Item,Nieprawidłowe zamówienie zbiorcze dla wybranego klienta i przedmiotu,
-Invalid Company for Inter Company Transaction.,Nieważna firma dla transakcji między przedsiębiorstwami.,
-Invalid GSTIN! A GSTIN must have 15 characters.,Nieprawidłowy GSTIN! GSTIN musi mieć 15 znaków.,
-Invalid GSTIN! First 2 digits of GSTIN should match with State number {0}.,Nieprawidłowy GSTIN! Pierwsze 2 cyfry GSTIN powinny pasować do numeru stanu {0}.,
-Invalid GSTIN! The input you've entered doesn't match the format of GSTIN.,Nieprawidłowy GSTIN! Wprowadzone dane nie pasują do formatu GSTIN.,
-Invalid Posting Time,Nieprawidłowy czas publikacji,
-Invalid attribute {0} {1},Nieprawidłowy atrybut {0} {1},
-Invalid quantity specified for item {0}. Quantity should be greater than 0.,Nieprawidłowa ilość określona dla elementu {0}. Ilość powinna być większa niż 0.,
-Invalid reference {0} {1},Nieprawidłowy odniesienia {0} {1},
-Invalid {0},Nieprawidłowy {0},
-Invalid {0} for Inter Company Transaction.,Nieprawidłowy {0} dla transakcji między przedsiębiorstwami.,
-Invalid {0}: {1},Nieprawidłowy {0}: {1},
-Inventory,Inwentarz,
-Investment Banking,Bankowość inwestycyjna,
-Investments,Inwestycje,
-Invoice,Faktura,
-Invoice Created,Utworzono fakturę,
-Invoice Discounting,Dyskontowanie faktury,
-Invoice Patient Registration,Rejestracja pacjenta faktury,
-Invoice Posting Date,Faktura Data zamieszczenia,
-Invoice Type,Typ faktury,
-Invoice already created for all billing hours,Faktura została już utworzona dla wszystkich godzin rozliczeniowych,
-Invoice can't be made for zero billing hour,Faktura nie może zostać wystawiona na zero godzin rozliczeniowych,
-Invoice {0} no longer exists,Faktura {0} już nie istnieje,
-Invoiced,Zafakturowane,
-Invoiced Amount,Kwota zafakturowana,
-Invoices,Faktury,
-Invoices for Costumers.,Faktury dla klientów.,
-Inward supplies from ISD,Dostawy wewnętrzne z ISD,
-Inward supplies liable to reverse charge (other than 1 & 2 above),Dostawy wewnętrzne podlegające zwrotowi (inne niż 1 i 2 powyżej),
-Is Active,Jest aktywny,
-Is Default,Jest domyślny,
-Is Existing Asset,Czy istniejącego środka trwałego,
-Is Frozen,Zamrożony,
-Is Group,Czy Grupa,
-Issue,Zdarzenie,
-Issue Material,Wydanie Materiał,
-Issued,Wydany,
-Issues,Zagadnienia,
-It is needed to fetch Item Details.,"Jest to niezbędne, aby pobrać szczegółowe dotyczące pozycji.",
-Item,Asortyment,
-Item 1,Pozycja 1,
-Item 2,Pozycja 2,
-Item 3,Pozycja 3,
-Item 4,Pozycja 4,
-Item 5,Pozycja 5,
-Item Cart,poz Koszyk,
-Item Code,Kod identyfikacyjny,
-Item Code cannot be changed for Serial No.,Kod przedmiotu nie może być zmieniony na podstawie numeru seryjnego,
-Item Code required at Row No {0},Wymagany jest kod elementu w wierszu nr {0},
-Item Description,Opis produktu,
-Item Group,Kategoria,
-Item Group Tree,Drzewo kategorii,
-Item Group not mentioned in item master for item {0},Pozycja Grupa nie wymienione w pozycji do pozycji mistrza {0},
-Item Name,Nazwa przedmiotu,
-Item Price added for {0} in Price List {1},Pozycja Cena dodany do {0} w Cenniku {1},
-"Item Price appears multiple times based on Price List, Supplier/Customer, Currency, Item, UOM, Qty and Dates.","Cena produktu pojawia się wiele razy w oparciu o Cennik, Dostawcę / Klienta, Walutę, Pozycję, UOM, Ilość i Daty.",
-Item Price updated for {0} in Price List {1},Pozycja Cena aktualizowana {0} w Cenniku {1},
-Item Row {0}: {1} {2} does not exist in above '{1}' table,Wiersz pozycji {0}: {1} {2} nie istnieje w powyższej tabeli &quot;{1}&quot;,
-Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,,
-Item Template,Szablon przedmiotu,
-Item Variant Settings,Ustawienia wariantu pozycji,
-Item Variant {0} already exists with same attributes,Pozycja Wersja {0} istnieje już z samymi atrybutami,
-Item Variants,Warianty artykuł,
-Item Variants updated,Zaktualizowano wariant produktu,
-Item has variants.,Pozycja ma warianty.,
-Item must be added using 'Get Items from Purchase Receipts' button,"Rzecz musi być dodane za ""elementy z zakupu wpływy"" przycisk",
-Item valuation rate is recalculated considering landed cost voucher amount,Jednostkowy wskaźnik wyceny przeliczone z uwzględnieniem kosztów ilość kupon wylądował,
-Item variant {0} exists with same attributes,Pozycja wariant {0} istnieje z samymi atrybutami,
-Item {0} does not exist,Element {0} nie istnieje,
-Item {0} does not exist in the system or has expired,Element {0} nie istnieje w systemie lub wygasł,
-Item {0} has already been returned,Element {0} został zwrócony,
-Item {0} has been disabled,Element {0} została wyłączona,
-Item {0} has reached its end of life on {1},Element {0} osiągnął kres przydatności {1},
-Item {0} ignored since it is not a stock item,"Element {0} jest ignorowany od momentu, kiedy nie ma go w magazynie",
-"Item {0} is a template, please select one of its variants","Element {0} jest szablon, należy wybrać jedną z jego odmian",
-Item {0} is cancelled,Element {0} jest anulowany,
-Item {0} is disabled,Element {0} jest wyłączony,
-Item {0} is not a serialized Item,,
-Item {0} is not a stock Item,Element {0} nie jest w magazynie,
-Item {0} is not active or end of life has been reached,"Element {0} nie jest aktywny, lub osiągnął datę przydatności",
-Item {0} is not setup for Serial Nos. Check Item master,Element {0} nie jest ustawiony na nr seryjny. Sprawdź mastera tego elementu,
-Item {0} is not setup for Serial Nos. Column must be blank,Element {0} nie jest ustawiony na nr seryjny. Kolumny powinny być puste,
-Item {0} must be a Fixed Asset Item,Element {0} musi być trwałego przedmiotu,
-Item {0} must be a Sub-contracted Item,,
-Item {0} must be a non-stock item,Element {0} musi być elementem non-stock,
-Item {0} must be a stock Item,Item {0} musi być dostępna w magazynie,
-Item {0} not found,Element {0} nie został znaleziony,
-Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Element {0} nie znajdują się w &quot;materiały dostarczane&quot; tabeli w Zamówieniu {1},
-Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Element {0}: Zamówione szt {1} nie może być mniejsza niż minimalna Ilość zamówień {2} (określonego w pkt).,
-Item: {0} does not exist in the system,Pozycja: {0} nie istnieje w systemie,
-Items,Produkty,
-Items Filter,Elementy Filtruj,
-Items and Pricing,Produkty i cennik,
-Items for Raw Material Request,Elementy do żądania surowca,
-Job Card,Karta pracy,
-Job Description,Opis stanowiska Pracy,
-Job Offer,Oferta pracy,
-Job card {0} created,Utworzono kartę zadania {0},
-Jobs,Oferty pracy,
-Join,łączyć,
-Journal Entries {0} are un-linked,Zapisy księgowe {0} nie są powiązane,
-Journal Entry,Zapis księgowy,
-Journal Entry {0} does not have account {1} or already matched against other voucher,Księgowanie {0} nie masz konta {1} lub już porównywane inne bon,
-Kanban Board,Kanban Board,
-Key Reports,Kluczowe raporty,
-LMS Activity,Aktywność LMS,
-Lab Test,Test laboratoryjny,
-Lab Test Report,Raport z testów laboratoryjnych,
-Lab Test Sample,Próbka do badań laboratoryjnych,
-Lab Test Template,Szablon testu laboratoryjnego,
-Lab Test UOM,Lab Test UOM,
-Lab Tests and Vital Signs,Testy laboratoryjne i Vital Signs,
-Lab result datetime cannot be before testing datetime,Data zestawienia wyników laboratorium nie może być wcześniejsza niż test datetime,
-Lab testing datetime cannot be before collection datetime,Data testowania laboratorium nie może być datą zbierania danych,
-Label,etykieta,
-Laboratory,Laboratorium,
-Language Name,Nazwa Język,
-Large,Duży,
-Last Communication,Ostatnia komunikacja,
-Last Communication Date,Ostatni dzień komunikacji,
-Last Name,Nazwisko,
-Last Order Amount,Kwota ostatniego zamówienia,
-Last Order Date,Data ostatniego zamówienia,
-Last Purchase Price,Ostatnia cena zakupu,
-Last Purchase Rate,Data Ostatniego Zakupu,
-Latest,Ostatnie,
-Latest price updated in all BOMs,Aktualna cena została zaktualizowana we wszystkich biuletynach,
-Lead,Potencjalny klient,
-Lead Count,Liczba potencjalnych klientów,
-Lead Owner,Właściciel Tropu,
-Lead Owner cannot be same as the Lead,Ołów Właściciel nie może być taka sama jak Lead,
-Lead Time Days,Czas realizacji (dni),
-Lead to Quotation,Trop do Wyceny,
-"Leads help you get business, add all your contacts and more as your leads","Przewody pomóc biznesu, dodać wszystkie kontakty i więcej jak swoich klientów",
-Learn,Samouczek,
-Leave Approval Notification,Powiadomienie o zmianie zatwierdzającego Nieobecność,
-Leave Blocked,Urlop Zablokowany,
-Leave Encashment,Zostawić Inkaso,
-Leave Management,Zarządzanie Nieobecnościami,
-Leave Status Notification,Powiadomienie o Statusie zgłoszonej Nieobecności,
-Leave Type,Typ urlopu,
-Leave Type is madatory,Typ Nieobecności jest polem wymaganym,
-Leave Type {0} cannot be allocated since it is leave without pay,"Typ Nieobecności {0} nie może zostać zaalokowany, ponieważ jest Urlopem Bezpłatnym",
-Leave Type {0} cannot be carry-forwarded,Typ Nieobecności {0} nie może zostać przeniesiony w przyszłość,
-Leave Type {0} is not encashable,Typ opuszczenia {0} nie podlega szyfrowaniu,
-Leave Without Pay,Urlop bezpłatny,
-Leave and Attendance,Nieobecności i Obecności,
-Leave application {0} already exists against the student {1},Pozostaw aplikację {0} już istnieje przeciwko uczniowi {1},
-"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Nieobecność nie może być przyznana przed {0}, a bilans nieobecności został już przeniesiony na przyszły wpis alokacyjny nieobecności {1}",
-"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Zostaw nie mogą być stosowane / anulowana przed {0}, a bilans urlopu zostało już przeniesionych przekazywane w przyszłości rekordu alokacji urlopu {1}",
-Leave of type {0} cannot be longer than {1},Urlop typu {0} nie może być dłuższy niż {1},
-Leaves,Odchodzi,
-Leaves Allocated Successfully for {0},Nieobecności Przedzielono z Powodzeniem dla {0},
-Leaves has been granted sucessfully,Nieobecności zostały przyznane z powodzeniem,
-Leaves must be allocated in multiples of 0.5,"Urlop musi być zdefiniowany jako wielokrotność liczby ""0.5""",
-Leaves per Year,Nieobecności w Roku,
-Ledger,Rejestr,
-Legal,Legalnie,
-Legal Expenses,Wydatki na obsługę prawną,
-Letter Head,Nagłówek,
-Letter Heads for print templates.,Nagłówki dla szablonów druku,
-Level,Poziom,
-Liability,Zobowiązania,
-License,Licencja,
-Lifecycle,Koło życia,
-Limit,Limit,
-Limit Crossed,Limit Crossed,
-Link to Material Request,Link do żądania materiałowego,
-List of all share transactions,Lista wszystkich transakcji akcji,
-List of available Shareholders with folio numbers,Lista dostępnych Akcjonariuszy z numerami folio,
-Loading Payment System,Ładowanie systemu płatności,
-Loan,Pożyczka,
-Loan Amount cannot exceed Maximum Loan Amount of {0},Kwota kredytu nie może przekroczyć maksymalna kwota kredytu o {0},
-Loan Application,Podanie o pożyczkę,
-Loan Management,Zarządzanie kredytem,
-Loan Repayment,Spłata pożyczki,
-Loan Start Date and Loan Period are mandatory to save the Invoice Discounting,"Data rozpoczęcia pożyczki i okres pożyczki są obowiązkowe, aby zapisać dyskontowanie faktury",
-Loans (Liabilities),Kredyty (zobowiązania),
-Loans and Advances (Assets),Pożyczki i zaliczki (aktywa),
-Local,Lokalne,
-Log,Log,
-Logs for maintaining sms delivery status,Logi do utrzymania sms stan przesyłki,
-Lost,Straty,
-Lost Reasons,Przegrane przyczyny,
-Low,Niski,
-Low Sensitivity,Mała czułość,
-Lower Income,Niższy przychód,
-Loyalty Amount,Kwota lojalności,
-Loyalty Point Entry,Punkt lojalnościowy,
-Loyalty Points,Punkty lojalnościowe,
-"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Punkty lojalnościowe będą obliczane na podstawie zużytego (za pomocą faktury sprzedaży), na podstawie wspomnianego współczynnika zbierania.",
-Loyalty Points: {0},Punkty lojalnościowe: {0},
-Loyalty Program,Program lojalnościowy,
-Main,Główny,
-Maintenance,Konserwacja,
-Maintenance Log,Dziennik konserwacji,
-Maintenance Manager,Menager Konserwacji,
-Maintenance Schedule,Plan Konserwacji,
-Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Plan Konserwacji nie jest generowany dla wszystkich przedmiotów. Proszę naciśnij ""generuj plan""",
-Maintenance Schedule {0} exists against {1},Harmonogram konserwacji {0} istnieje przeciwko {1},
-Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Plan Konserwacji {0} musi być anulowany przed usunięciem tego zamówienia,
-Maintenance Status has to be Cancelled or Completed to Submit,Stan konserwacji musi zostać anulowany lub uzupełniony do przesłania,
-Maintenance User,Użytkownik Konserwacji,
-Maintenance Visit,Wizyta Konserwacji,
-Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Wizyta Konserwacji {0} musi być anulowana przed usunięciem nakazu sprzedaży,
-Maintenance start date can not be before delivery date for Serial No {0},Początek daty konserwacji nie może być wcześniejszy od daty numeru seryjnego {0},
-Make,Stwórz,
-Make Payment,Dokonać płatności,
-Make project from a template.,Utwórz projekt z szablonu.,
-Making Stock Entries,Dokonywanie stockowe Wpisy,
-Male,Mężczyzna,
-Manage Customer Group Tree.,Zarządzaj drzewem grupy klientów,
-Manage Sales Partners.,Zarządzaj Partnerami Sprzedaży.,
-Manage Sales Person Tree.,Zarządzaj Drzewem Sprzedawców,
-Manage Territory Tree.,Zarządzaj drzewem terytorium,
-Manage your orders,Zarządzanie zamówień,
-Management,Zarząd,
-Manager,Menager,
-Managing Projects,Zarządzanie projektami,
-Managing Subcontracting,Zarządzanie Podwykonawstwo,
-Mandatory,Obowiązkowe,
-Mandatory field - Academic Year,Pole obowiązkowe - Rok akademicki,
-Mandatory field - Get Students From,Pole obowiązkowe - pobierz uczniów,
-Mandatory field - Program,Pole obowiązkowe - program,
-Manufacture,Produkcja,
-Manufacturer,Producent,
-Manufacturer Part Number,Numer katalogowy producenta,
-Manufacturing,Produkcja,
-Manufacturing Quantity is mandatory,Ilość wyprodukowanych jest obowiązkowa,
-Mapping,Mapowanie,
-Mapping Type,Typ odwzorowania,
-Mark Absent,Oznacz Nieobecna,
-Mark Attendance,Oznaczaj Uczestnictwo,
-Mark Half Day,Oznacz pół dnia,
-Mark Present,Mark Present,
-Marketing,Marketing,
-Marketing Expenses,Wydatki marketingowe,
-Marketplace,Rynek,
-Marketplace Error,Błąd na rynku,
-Masters,Magistrowie,
-Match Payments with Invoices,Płatności mecz fakturami,
-Match non-linked Invoices and Payments.,Łączenie faktur z płatnościami,
-Material,Materiał,
-Material Consumption,Zużycie materiału,
-Material Consumption is not set in Manufacturing Settings.,Zużycie materiału nie jest ustawione w ustawieniach produkcyjnych.,
-Material Receipt,Przyjęcie materiałów,
-Material Request,Zamówienie produktu,
-Material Request Date,Materiał Zapytanie Data,
-Material Request No,Zamówienie produktu nr,
-"Material Request not created, as quantity for Raw Materials already available.","Nie utworzono wniosku o materiał, jako ilość dostępnych surowców.",
-Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Zamówienie produktu o maksymalnej ilości {0} może być zrealizowane dla przedmiotu {1} w zamówieniu {2},
-Material Request to Purchase Order,Twoje zamówienie jest w realizacji,
-Material Request {0} is cancelled or stopped,Zamówienie produktu {0} jest anulowane lub wstrzymane,
-Material Request {0} submitted.,Wysłano żądanie materiałowe {0}.,
-Material Transfer,Transfer materiałów,
-Material Transferred,Przeniesiony materiał,
-Material to Supplier,Materiał do dostawcy,
-Max Exemption Amount cannot be greater than maximum exemption amount {0} of Tax Exemption Category {1},Maksymalna kwota zwolnienia nie może być większa niż maksymalna kwota zwolnienia {0} kategorii zwolnienia podatkowego {1},
-Max benefits should be greater than zero to dispense benefits,Maksymalne korzyści powinny być większe niż zero w celu rozłożenia korzyści,
-Max discount allowed for item: {0} is {1}%,Maksymalna zniżka pozwoliło na pozycji: {0} jest {1}%,
-Max: {0},Max: {0},
-Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Maksymalne próbki - {0} mogą zostać zachowane dla Batch {1} i Item {2}.,
-Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maksymalne próbki - {0} zostały już zachowane dla partii {1} i pozycji {2} w partii {3}.,
-Maximum amount eligible for the component {0} exceeds {1},Maksymalna kwota kwalifikująca się do komponentu {0} przekracza {1},
-Maximum benefit amount of component {0} exceeds {1},Maksymalna kwota świadczenia komponentu {0} przekracza {1},
-Maximum benefit amount of employee {0} exceeds {1},Maksymalna kwota świadczenia pracownika {0} przekracza {1},
-Maximum discount for Item {0} is {1}%,Maksymalna zniżka dla pozycji {0} to {1}%,
-Maximum leave allowed in the leave type {0} is {1},Maksymalny dozwolony urlop w typie urlopu {0} to {1},
-Medical,Medyczny,
-Medical Code,Kodeks medyczny,
-Medical Code Standard,Standardowy kod medyczny,
-Medical Department,Wydział Lekarski,
-Medical Record,Historia choroby,
-Medium,Średni,
-Meeting,Spotkanie,
-Member Activity,Aktywność użytkownika,
-Member ID,ID Użytkownika,
-Member Name,Nazwa członka,
-Member information.,Informacje o członkach.,
-Membership,Członkostwo,
-Membership Details,Dane dotyczące członkostwa,
-Membership ID,Identyfikator członkostwa,
-Membership Type,typ członkostwa,
-Memebership Details,Szczegóły Memebership,
-Memebership Type Details,Szczegóły typu memebership,
-Merge,Łączyć,
-Merge Account,Połącz konto,
-Merge with Existing Account,Scal z istniejącym kontem,
-"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Połączenie jest możliwe tylko wtedy, gdy następujące właściwości są takie same w obu płyt. Czy Grupa Root Typ, Firma",
-Message Examples,Przykłady wiadomości,
-Message Sent,Wiadomość wysłana,
-Method,Metoda,
-Middle Income,Średni dochód,
-Middle Name,Drugie imię,
-Middle Name (Optional),Drugie imię (opcjonalnie),
-Min Amt can not be greater than Max Amt,Min Amt nie może być większy niż Max Amt,
-Min Qty can not be greater than Max Qty,Minimalna ilość nie może być większa niż maksymalna ilość,
-Minimum Lead Age (Days),Minimalny wiek ołowiu (dni),
-Miscellaneous Expenses,Pozostałe drobne wydatki,
-Missing Currency Exchange Rates for {0},Brakujące Wymiana walut stawki dla {0},
-Missing email template for dispatch. Please set one in Delivery Settings.,Brakujący szablon wiadomości e-mail do wysyłki. Ustaw jeden w Ustawieniach dostawy.,
-"Missing value for Password, API Key or Shopify URL","Brakująca wartość hasła, klucza API lub Shopify URL",
-Mode of Payment,Sposób płatności,
-Mode of Payments,Tryb płatności,
-Mode of Transport,Tryb transportu,
-Mode of Transportation,Środek transportu,
-Mode of payment is required to make a payment,"Sposób płatności jest wymagane, aby dokonać płatności",
-Model,Model,
-Moderate Sensitivity,Średnia czułość,
-Monday,Poniedziałek,
-Monthly,Miesięcznie,
-Monthly Distribution,Miesięczny Dystrybucja,
-Monthly Repayment Amount cannot be greater than Loan Amount,Miesięczna kwota spłaty nie może być większa niż Kwota kredytu,
-More,Więcej,
-More Information,Więcej informacji,
-More than one selection for {0} not allowed,Więcej niż jeden wybór dla {0} jest niedozwolony,
-More...,Jeszcze...,
-Motion Picture & Video,Ruchomy Obraz i Video,
-Move,ruch,
-Move Item,Move Item,
-Multi Currency,Wielowalutowy,
-Multiple Item prices.,Wiele cen przedmiotu.,
-Multiple Loyalty Program found for the Customer. Please select manually.,Znaleziono wiele programów lojalnościowych dla klienta. Wybierz ręcznie.,
-"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}",Wiele Zasad Cen istnieje w tych samych kryteriach proszę rozwiązywania konflikty poprzez przypisanie priorytetu. Zasady Cen: {0},
-Multiple Variants,Wiele wariantów,
-Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Wiele lat podatkowych istnieją na dzień {0}. Proszę ustawić firmy w roku finansowym,
-Music,Muzyka,
-My Account,Moje Konto,
-Name error: {0},Błąd Nazwa: {0},
-Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Nazwa nowego konta. Uwaga: Proszę nie tworzyć konta dla odbiorców i dostawców,
-Name or Email is mandatory,Imię lub E-mail jest obowiązkowe,
-Nature Of Supplies,Natura dostaw,
-Navigating,Nawigacja,
-Needs Analysis,Analiza potrzeb,
-Negative Quantity is not allowed,Ilość nie może być wyrażana na minusie,
-Negative Valuation Rate is not allowed,Błąd Szacowania Wartość nie jest dozwolona,
-Negotiation/Review,Negocjacje / przegląd,
-Net Asset value as on,Wartość aktywów netto na,
-Net Cash from Financing,Przepływy pieniężne netto z finansowania,
-Net Cash from Investing,Przepływy pieniężne netto z inwestycji,
-Net Cash from Operations,Środki pieniężne netto z działalności operacyjnej,
-Net Change in Accounts Payable,Zmiana netto stanu zobowiązań,
-Net Change in Accounts Receivable,Zmiana netto stanu należności,
-Net Change in Cash,Zmiana netto stanu środków pieniężnych,
-Net Change in Equity,Zmiana netto w kapitale własnym,
-Net Change in Fixed Asset,Zmiana netto stanu trwałego,
-Net Change in Inventory,Zmiana netto stanu zapasów,
-Net ITC Available(A) - (B),Net ITC Available (A) - (B),
-Net Pay,Stawka Netto,
-Net Pay cannot be less than 0,Wynagrodzenie netto nie może być mniejsza niż 0,
-Net Profit,Zysk netto,
-Net Salary Amount,Kwota wynagrodzenia netto,
-Net Total,Łączna wartość netto,
-Net pay cannot be negative,Stawka Netto nie może być na minusie,
-New Account Name,Nowa nazwa konta,
-New Address,Nowy adres,
-New BOM,Nowe zestawienie materiałowe,
-New Batch ID (Optional),Nowy identyfikator partii (opcjonalnie),
-New Batch Qty,Nowa partia,
-New Company,Nowa firma,
-New Cost Center Name,Nazwa nowego Centrum Kosztów,
-New Customer Revenue,Nowy Przychody klienta,
-New Customers,Nowi Klienci,
-New Department,Nowy dział,
-New Employee,Nowy pracownik,
-New Location,Nowa lokalizacja,
-New Quality Procedure,Nowa procedura jakości,
-New Sales Invoice,Nowa faktura sprzedaży,
-New Sales Person Name,Nazwa nowej osoby Sprzedaży,
-New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Nowy nr seryjny nie może mieć Magazynu. Magazyn musi być ustawiona przez Zasoby lub  na podstawie Paragonu Zakupu,
-New Warehouse Name,Nowy magazyn Nazwa,
-New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Nowy limit kredytowy wynosi poniżej aktualnej kwoty należności dla klienta. Limit kredytowy musi być conajmniej {0},
-New task,Nowe zadanie,
-New {0} pricing rules are created,Utworzono nowe {0} reguły cenowe,
-Newsletters,Biuletyny,
-Newspaper Publishers,Wydawcy gazet,
-Next,Dalej,
-Next Contact By cannot be same as the Lead Email Address,Następnie Kontakt By nie może być taki sam jak adres e-mail Wiodącego,
-Next Contact Date cannot be in the past,Następnie Kontakt Data nie może być w przeszłości,
-Next Steps,Następne kroki,
-No Action,Bez akcji,
-No Customers yet!,Brak klientów!,
-No Data,Brak danych,
-No Delivery Note selected for Customer {},Nie wybrano uwagi dostawy dla klienta {},
-No Employee Found,Nie znaleziono pracownika,
-No Item with Barcode {0},Nie istnieje Przedmiot o kodzie kreskowym {0},
-No Item with Serial No {0},Brak przedmiotu o podanym numerze seryjnym {0},
-No Items available for transfer,Brak przedmiotów do przeniesienia,
-No Items selected for transfer,Nie wybrano pozycji do przeniesienia,
-No Items to pack,Brak Przedmiotów do pakowania,
-No Items with Bill of Materials to Manufacture,Brak przedmioty z Bill of Materials do produkcji,
-No Items with Bill of Materials.,Brak przedmiotów z zestawieniem materiałów.,
-No Permission,Brak uprawnień,
-No Remarks,Brak uwag,
-No Result to submit,Brak wyniku,
-No Salary Structure assigned for Employee {0} on given date {1},Brak struktury wynagrodzenia dla pracownika {0} w danym dniu {1},
-No Staffing Plans found for this Designation,Nie znaleziono planów zatrudnienia dla tego oznaczenia,
-No Student Groups created.,Brak grup studenckich utworzony.,
-No Students in,Brak uczniów w Poznaniu,
-No Tax Withholding data found for the current Fiscal Year.,Nie znaleziono danych potrącenia podatku dla bieżącego roku obrotowego.,
-No Work Orders created,Nie utworzono zleceń pracy,
-No accounting entries for the following warehouses,Brak zapisów księgowych dla następujących magazynów,
-No active or default Salary Structure found for employee {0} for the given dates,Brak aktywnego czy ustawiona Wynagrodzenie Struktura znalezionych dla pracownika {0} dla podanych dat,
-No contacts with email IDs found.,Nie znaleziono kontaktów z identyfikatorami e-mail.,
-No data for this period,Brak danych dla tego okresu,
-No description given,Brak opisu,
-No employees for the mentioned criteria,Brak pracowników dla wymienionych kryteriów,
-No gain or loss in the exchange rate,Brak zysków lub strat w kursie wymiany,
-No items listed,Brak elementów na liście,
-No items to be received are overdue,Żadne przedmioty do odbioru nie są spóźnione,
-No material request created,Nie utworzono żadnego żadnego materialnego wniosku,
-No more updates,Brak więcej aktualizacji,
-No of Interactions,Liczba interakcji,
-No of Shares,Liczba akcji,
-No pending Material Requests found to link for the given items.,Nie znaleziono oczekujĘ ... cych żĘ ... danych żĘ ... danych w celu połĘ ... czenia dla podanych elementów.,
-No products found,Nie znaleziono produktów,
-No products found.,Nie znaleziono produktów.,
-No record found,Nie znaleziono wyników,
-No records found in the Invoice table,Nie znaleziono w tabeli faktury rekordy,
-No records found in the Payment table,Nie znaleziono rekordów w tabeli płatności,
-No replies from,Brak odpowiedzi ze strony,
-No salary slip found to submit for the above selected criteria OR salary slip already submitted,Nie znaleziono pokwitowania wypłaty za wyżej wymienione kryteria LUB wniosek o wypłatę wynagrodzenia już przesłano,
-No tasks,Brak zadań,
-No time sheets,Brak karty czasu,
-No values,Brak wartości,
-No {0} found for Inter Company Transactions.,"Nie znaleziono rekordów ""{0}"" dla transakcji między spółkami.",
-Non GST Inward Supplies,Non GST Inward Supplies,
-Non Profit,Brak Zysków,
-Non Profit (beta),Non Profit (beta),
-Non-GST outward supplies,Dostawy zewnętrzne spoza GST,
-Non-Group to Group,Dla grupy do grupy,
-None,Żaden,
-None of the items have any change in quantity or value.,Żaden z elementów ma żadnych zmian w ilości lub wartości.,
-Nos,Numery,
-Not Available,Niedostępny,
-Not Marked,nieoznaczone,
-Not Paid and Not Delivered,Nie Płatny i nie Dostarczany,
-Not Permitted,Niedozwolone,
-Not Started,Nie Rozpoczęte,
-Not active,Nieaktywny,
-Not allow to set alternative item for the item {0},Nie zezwalaj na ustawienie pozycji alternatywnej dla pozycji {0},
-Not allowed to update stock transactions older than {0},Niedozwolona jest modyfikacja transakcji zapasów starszych niż {0},
-Not authorized to edit frozen Account {0},Brak autoryzacji do edycji zamrożonego Konta {0},
-Not authroized since {0} exceeds limits,Brak autoryzacji od {0} przekroczono granice,
-Not permitted for {0},Nie dopuszczony do {0},
-"Not permitted, configure Lab Test Template as required","Niedozwolone, w razie potrzeby skonfiguruj szablon testu laboratorium",
-Not permitted. Please disable the Service Unit Type,Nie dozwolone. Wyłącz opcję Service Unit Type,
-Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Uwaga: Ze względu / Data odniesienia przekracza dozwolony dzień kredytowej klienta przez {0} dni (s),
-Note: Item {0} entered multiple times,Uwaga: Element {0} wpisano kilka razy,
-Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Uwaga: Płatność nie zostanie utworzona, gdyż nie określono konta 'Gotówka lub Bank'",
-Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Uwaga: System nie sprawdza nad-dostawy oraz nadmiernej rezerwacji dla pozycji {0} jej wartość lub kwota wynosi 0,
-Note: There is not enough leave balance for Leave Type {0},Uwaga: Nie ma wystarczającej ilości urlopu aby ustalić typ zwolnienia {0},
-Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Informacja: To Centrum Kosztów jest grupą. Nie mogę wykonać operacji rachunkowych na grupach.,
-Note: {0},Uwaga: {0},
-Notes,Notatki,
-Nothing is included in gross,Nic nie jest wliczone w brutto,
-Nothing more to show.,Nic więcej do pokazania.,
-Nothing to change,Nic do zmiany,
-Notice Period,Okres wypowiedzenia,
-Notify Customers via Email,Powiadom klientów przez e-mail,
-Number,Numer,
-Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Ilość amortyzacją Zarezerwowane nie może być większa od ogólnej liczby amortyzacją,
-Number of Interaction,Liczba interakcji,
-Number of Order,Numer zlecenia,
-"Number of new Account, it will be included in the account name as a prefix","Numer nowego Konta, zostanie dodany do nazwy konta jako prefiks",
-"Number of new Cost Center, it will be included in the cost center name as a prefix","Numer nowego miejsca powstawania kosztów, zostanie wprowadzony do nazwy miejsca powstawania kosztów jako prefiks",
-Number of root accounts cannot be less than 4,Liczba kont root nie może być mniejsza niż 4,
-Odometer,Drogomierz,
-Office Equipments,Urządzenie Biura,
-Office Maintenance Expenses,Wydatki na obsługę biura,
-Office Rent,Wydatki na wynajem,
-On Hold,W oczekiwaniu,
-On Net Total,Na podstawie Kwoty Netto,
-One customer can be part of only single Loyalty Program.,Jeden klient może być częścią tylko jednego Programu lojalnościowego.,
-Online Auctions,Aukcje online,
-Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Pozostawić tylko Aplikacje ze statusem „Approved” i „Odrzucone” mogą być składane,
-"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",W poniższej tabeli zostanie wybrana tylko osoba ubiegająca się o przyjęcie ze statusem &quot;Zatwierdzona&quot;.,
-Only users with {0} role can register on Marketplace,Tylko użytkownicy z rolą {0} mogą rejestrować się w usłudze Marketplace,
-Open BOM {0},Otwarte BOM {0},
-Open Item {0},Pozycja otwarta {0},
-Open Notifications,Otwarte Powiadomienia,
-Open Orders,Otwarte zlecenia,
-Open a new ticket,Otwórz nowy bilet,
-Opening,Otwarcie,
-Opening (Cr),Otwarcie (Cr),
-Opening (Dr),Otwarcie (Dr),
-Opening Accounting Balance,Stan z bilansu otwarcia,
-Opening Accumulated Depreciation,Otwarcie Skumulowana amortyzacja,
-Opening Accumulated Depreciation must be less than equal to {0},Otwarcie Skumulowana amortyzacja powinna być mniejsza niż równa {0},
-Opening Balance,Bilans otwarcia,
-Opening Balance Equity,Bilans otwarcia Kapitału własnego,
-Opening Date and Closing Date should be within same Fiscal Year,Otwarcie Data i termin powinien być w obrębie samego roku podatkowego,
-Opening Date should be before Closing Date,Data otwarcia powinien być przed Dniem Zamknięcia,
-Opening Entry Journal,Otwarcie dziennika wejścia,
-Opening Invoice Creation Tool,Otwieranie narzędzia tworzenia faktury,
-Opening Invoice Item,Otwieranie faktury,
-Opening Invoices,Otwieranie faktur,
-Opening Invoices Summary,Otwieranie podsumowań faktur,
-Opening Qty,Ilość otwarcia,
-Opening Stock,Otwarcie Zdjęcie,
-Opening Stock Balance,Saldo otwierające zapasy,
-Opening Value,Wartość otwarcia,
-Opening {0} Invoice created,Otworzono fakturę {0},
-Operation,Operacja,
-Operation Time must be greater than 0 for Operation {0},Czas działania musi być większy niż 0 do operacji {0},
-"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Operacja {0} dłużej niż wszelkie dostępne w godzinach pracy stacji roboczej {1}, rozbić na kilka operacji operacji",
-Operations,Działania,
-Operations cannot be left blank,Operacje nie może być puste,
-Opp Count,Opp Count,
-Opp/Lead %,Opp / ołów%,
-Opportunities,Możliwości,
-Opportunities by lead source,Możliwości według źródła ołowiu,
-Opportunity,Oferta,
-Opportunity Amount,Kwota możliwości,
-Optional Holiday List not set for leave period {0},Opcjonalna lista dni świątecznych nie jest ustawiona dla okresu urlopu {0},
-"Optional. Sets company's default currency, if not specified.","Opcjonalny. Ustawia domyślną walutę firmy, jeśli nie podano.",
-Optional. This setting will be used to filter in various transactions.,Opcjonalne. Te Ustawienie będzie użyte w filtrze dla różnych transacji.,
-Options,Opcje,
-Order Count,Liczba zamówień,
-Order Entry,Wprowadzanie zamówień,
-Order Value,Wartość zamówienia,
-Order rescheduled for sync,Zamów zmianę terminu do synchronizacji,
-Order/Quot %,Zamówienie / kwota%,
-Ordered,Zamówione,
-Ordered Qty,Ilość Zamówiona,
-"Ordered Qty: Quantity ordered for purchase, but not received.",,
-Orders,Zamówienia,
-Orders released for production.,Zamówienia puszczone do produkcji.,
-Organization,Organizacja,
-Organization Name,Nazwa organizacji,
-Other,Inne,
-Other Reports,Inne raporty,
-"Other outward supplies(Nil rated,Exempted)","Inne dostawy zewnętrzne (bez oceny, zwolnione)",
-Others,Inni,
-Out Qty,Brak Ilości,
-Out Value,Brak Wartości,
-Out of Order,Nieczynny,
-Outgoing,Wychodzący,
-Outstanding,Wybitny,
-Outstanding Amount,Zaległa Ilość,
-Outstanding Amt,Zaległa wartość,
-Outstanding Cheques and Deposits to clear,"Wybitni Czeki i depozytów, aby usunąć",
-Outstanding for {0} cannot be less than zero ({1}),Zaległość za {0} nie może być mniejsza niż ({1}),
-Outward taxable supplies(zero rated),Dostaw podlegających opodatkowaniu zewnętrznemu (zero punktów),
-Overdue,Zaległy,
-Overlap in scoring between {0} and {1},Pokrywaj się w punktacji pomiędzy {0} a {1},
-Overlapping conditions found between:,Nakładające warunki pomiędzy:,
-Owner,Właściciel,
-PAN,Stały numer konta (PAN),
-POS,POS,
-POS Profile,POS profilu,
-POS Profile is required to use Point-of-Sale,Profil POS jest wymagany do korzystania z Point-of-Sale,
-POS Profile required to make POS Entry,Profil POS wymagany do tworzenia wpisu z POS,
-POS Settings,Ustawienia POS,
-Packed quantity must equal quantity for Item {0} in row {1},Wartość spakowana musi równać się ilości dla przedmiotu {0} w rzędzie {1},
-Packing Slip,List przewozowy,
-Packing Slip(s) cancelled,List(y) przewozowe anulowane,
-Paid,Zapłacono,
-Paid Amount,Zapłacona kwota,
-Paid Amount cannot be greater than total negative outstanding amount {0},Wpłaconej kwoty nie może być większa od całkowitej ujemnej kwoty należności {0},
-Paid amount + Write Off Amount can not be greater than Grand Total,Wartość zapłaty + Wartość odliczenia nie może być większa niż Cała Kwota,
-Paid and Not Delivered,Płatny i niedostarczone,
-Parameter,Parametr,
-Parent Item {0} must not be a Stock Item,Dominująca pozycja {0} nie może być pozycja Zdjęcie,
-Parents Teacher Meeting Attendance,Spotkanie wychowawców rodziców,
-Part-time,Niepełnoetatowy,
-Partially Depreciated,częściowo Zamortyzowany,
-Partially Received,Częściowo odebrane,
-Party,Grupa,
-Party Name,Nazwa Party,
-Party Type,Typ grupy,
-Party Type and Party is mandatory for {0} account,Typ strony i strona są obowiązkowe dla konta {0},
-Party Type is mandatory,Rodzaj Partia jest obowiązkowe,
-Party is mandatory,Partia jest obowiązkowe,
-Password,Hasło,
-Password policy for Salary Slips is not set,Polityka haseł dla poświadczeń wynagrodzenia nie jest ustawiona,
-Past Due Date,Minione terminy,
-Patient,Cierpliwy,
-Patient Appointment,Powtarzanie Pacjenta,
-Patient Encounter,Spotkanie z pacjentem,
-Patient not found,Nie znaleziono pacjenta,
-Pay Remaining,Zapłać pozostałe,
-Pay {0} {1},Zapłać {0} {1},
-Payable,Płatność,
-Payable Account,Konto płatności,
-Payable Amount,Kwota do zapłaty,
-Payment,Płatność,
-Payment Cancelled. Please check your GoCardless Account for more details,"Płatność anulowana. Sprawdź swoje konto bez karty, aby uzyskać więcej informacji",
-Payment Confirmation,Potwierdzenie płatności,
-Payment Date,Data płatności,
-Payment Days,Dni płatności,
-Payment Document,Płatność Dokument,
-Payment Due Date,Termin płatności,
-Payment Entries {0} are un-linked,Wpisy płatności {0} są un-linked,
-Payment Entry,Płatność,
-Payment Entry already exists,Zapis takiej Płatności już istnieje,
-Payment Entry has been modified after you pulled it. Please pull it again.,Wpis płatności został zmodyfikowany po ściągnięciu. Proszę ściągnąć ponownie.,
-Payment Entry is already created,Zapis takiej Płatności już został utworzony,
-Payment Failed. Please check your GoCardless Account for more details,"Płatność nie powiodła się. Sprawdź swoje konto bez karty, aby uzyskać więcej informacji",
-Payment Gateway,Bramki płatności,
-"Payment Gateway Account not created, please create one manually.","Payment Gateway konta nie jest tworzony, należy utworzyć ręcznie.",
-Payment Gateway Name,Nazwa bramki płatności,
-Payment Mode,Tryb Płatności,
-Payment Receipt Note,Otrzymanie płatności Uwaga,
-Payment Request,Żądanie zapłaty,
-Payment Request for {0},Prośba o płatność za {0},
-Payment Tems,Tematyka płatności,
-Payment Term,Termin płatności,
-Payment Terms,Zasady płatności,
-Payment Terms Template,Szablon warunków płatności,
-Payment Terms based on conditions,Warunki płatności oparte na warunkach,
-Payment Type,Typ płatności,
-"Payment Type must be one of Receive, Pay and Internal Transfer",Typ płatności musi być jednym z Odbierz Pay and przelew wewnętrzny,
-Payment against {0} {1} cannot be greater than Outstanding Amount {2},Płatność przed {0} {1} nie może być większa niż kwota kredytu pozostała {2},
-Payment of {0} from {1} to {2},Płatność {0} od {1} do {2},
-Payment request {0} created,Żądanie zapłaty {0} zostało utworzone,
-Payments,Płatności,
-Payroll,Lista płac,
-Payroll Number,Numer listy płac,
-Payroll Payable,Płace Płatne,
-Payslip,Odcinek wypłaty,
-Pending Activities,Oczekujące Inne,
-Pending Amount,Kwota Oczekiwana,
-Pending Leaves,Oczekujące Nieobecności,
-Pending Qty,Oczekuje szt,
-Pending Quantity,Ilość oczekująca,
-Pending Review,Czekający na rewizję,
-Pending activities for today,Działania oczekujące na dziś,
-Pension Funds,Fundusze emerytalne,
-Percentage Allocation should be equal to 100%,Przydział Procentowy powinien wynosić 100%,
-Perception Analysis,Analiza percepcji,
-Period,Okres,
-Period Closing Entry,Wpis Kończący Okres,
-Period Closing Voucher,Zamknięcie roku,
-Periodicity,Okresowość,
-Personal Details,Dane osobowe,
-Pharmaceutical,Farmaceutyczny,
-Pharmaceuticals,Farmaceutyczne,
-Physician,Lekarz,
-Piecework,Praca akordowa,
-Pincode,Kod PIN,
-Place Of Supply (State/UT),Miejsce zaopatrzenia (stan / UT),
-Place Order,Złóż zamówienie,
-Plan Name,Nazwa planu,
-Plan for maintenance visits.,Plan wizyt serwisowych.,
-Planned Qty,Planowana ilość,
-"Planned Qty: Quantity, for which, Work Order has been raised, but is pending to be manufactured.","Planowana ilość: ilość, dla której zlecenie pracy zostało podniesione, ale oczekuje na wyprodukowanie.",
-Planning,Planowanie,
-Plants and Machineries,Rośliny i maszyn,
-Please Set Supplier Group in Buying Settings.,Ustaw grupę dostawców w ustawieniach zakupów.,
-Please add a Temporary Opening account in Chart of Accounts,Dodaj konto tymczasowego otwarcia w planie kont,
-Please add the account to root level Company - ,Dodaj konto do poziomu głównego firmy -,
-Please add the remaining benefits {0} to any of the existing component,Dodaj pozostałe korzyści {0} do dowolnego z istniejących komponentów,
-Please check Multi Currency option to allow accounts with other currency,"Proszę sprawdzić multi opcji walutowych, aby umożliwić rachunki w innych walutach",
-Please click on 'Generate Schedule',"Proszę kliknąć na ""Wygeneruj Harmonogram""",
-Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Proszę kliknąć na ""Generowanie Harmonogramu"", aby sprowadzić nr seryjny dodany do pozycji {0}",
-Please click on 'Generate Schedule' to get schedule,"Kliknij na ""Generuj Harmonogram"" aby otrzymać harmonogram",
-Please confirm once you have completed your training,Potwierdź po zakończeniu szkolenia,
-Please create purchase receipt or purchase invoice for the item {0},Utwórz paragon zakupu lub fakturę zakupu elementu {0},
-Please define grade for Threshold 0%,Proszę określić stopień dla progu 0%,
-Please enable Applicable on Booking Actual Expenses,Włącz opcję Rzeczywiste wydatki za rezerwację,
-Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,Włącz Włączone do zamówienia i obowiązujące przy rzeczywistych kosztach rezerwacji,
-Please enable default incoming account before creating Daily Work Summary Group,Włącz domyślne konto przychodzące przed utworzeniem Daily Summary Summary Group,
-Please enable pop-ups,Proszę włączyć pop-upy,
-Please enter 'Is Subcontracted' as Yes or No,"Proszę wprowadź ""Zlecona"" jako Tak lub Nie",
-Please enter API Consumer Key,Wprowadź klucz klienta API,
-Please enter API Consumer Secret,Wprowadź klucz tajny API,
-Please enter Account for Change Amount,Proszę wpisać uwagę do zmiany kwoty,
-Please enter Approving Role or Approving User,Proszę wprowadzić Rolę osoby zatwierdzającej dla użytkownika zatwierdzającego,
-Please enter Cost Center,Wprowadź Centrum kosztów,
-Please enter Delivery Date,Proszę podać datę doręczenia,
-Please enter Employee Id of this sales person,Proszę podać ID pracownika tej osoby ze sprzedaży,
-Please enter Expense Account,Wprowadź konto Wydatków,
-Please enter Item Code to get Batch Number,"Proszę wpisać kod produkt, aby uzyskać numer partii",
-Please enter Item Code to get batch no,Proszę wprowadzić Kod Produktu w celu przyporządkowania serii,
-Please enter Item first,Proszę najpierw wprowadzić Przedmiot,
-Please enter Maintaince Details first,Proszę wprowadzić szczegóły dotyczące konserwacji,
-Please enter Planned Qty for Item {0} at row {1},Proszę podać Planowane Ilości dla pozycji {0} w wierszu {1},
-Please enter Preferred Contact Email,Proszę wpisać Preferowany Kontakt Email,
-Please enter Production Item first,Wprowadź jako pierwszą Produkowaną Rzecz,
-Please enter Purchase Receipt first,Proszę wpierw wprowadzić dokument zakupu,
-Please enter Receipt Document,Proszę podać Otrzymanie dokumentu,
-Please enter Reference date,,
-Please enter Repayment Periods,Proszę wprowadzić okresy spłaty,
-Please enter Reqd by Date,Wprowadź datę realizacji,
-Please enter Woocommerce Server URL,Wprowadź adres URL serwera Woocommerce,
-Please enter Write Off Account,Proszę zdefiniować konto odpisów,
-Please enter atleast 1 invoice in the table,Wprowadź co najmniej jedną fakturę do tabelki,
-Please enter company first,Proszę najpierw wpisać Firmę,
-Please enter company name first,Proszę najpierw wpisać nazwę Firmy,
-Please enter default currency in Company Master,Proszę dodać domyślną walutę w Głównych Ustawieniach Firmy,
-Please enter message before sending,Proszę wpisać wiadomość przed wysłaniem,
-Please enter parent cost center,Proszę podać nadrzędne centrum kosztów,
-Please enter quantity for Item {0},Wprowadź ilość dla przedmiotu {0},
-Please enter relieving date.,,
-Please enter repayment Amount,Wpisz Kwota spłaty,
-Please enter valid Financial Year Start and End Dates,Proszę wpisać poprawny rok obrotowy od daty rozpoczęcia i zakończenia,
-Please enter valid email address,Proszę wprowadzić poprawny adres email,
-Please enter {0} first,Podaj {0} pierwszy,
-Please fill in all the details to generate Assessment Result.,"Proszę wypełnić wszystkie szczegóły, aby wygenerować wynik oceny.",
-Please identify/create Account (Group) for type - {0},Określ / utwórz konto (grupę) dla typu - {0},
-Please identify/create Account (Ledger) for type - {0},Zidentyfikuj / utwórz konto (księga) dla typu - {0},
-Please login as another user to register on Marketplace,"Zaloguj się jako inny użytkownik, aby zarejestrować się na rynku",
-Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,"Upewnij się, że na pewno chcesz usunąć wszystkie transakcje dla tej firmy. Twoje dane podstawowe pozostanie tak jak jest. Ta akcja nie można cofnąć.",
-Please mention Basic and HRA component in Company,Proszę wspomnieć o komponencie Basic i HRA w firmie,
-Please mention Round Off Account in Company,Proszę określić konto do zaokrągleń kwot w firmie,
-Please mention Round Off Cost Center in Company,Powołaj zaokrąglić centrum kosztów w Spółce,
-Please mention no of visits required,,
-Please mention the Lead Name in Lead {0},Zapoznaj się z nazwą wiodącego wiodącego {0},
-Please pull items from Delivery Note,Wyciągnij elementy z dowodu dostawy,
-Please register the SIREN number in the company information file,Zarejestruj numer SIREN w pliku z informacjami o firmie,
-Please remove this Invoice {0} from C-Form {1},Proszę usunąć tę fakturę {0} z C-Form {1},
-Please save the patient first,Najpierw zapisz pacjenta,
-Please save the report again to rebuild or update,"Zapisz raport ponownie, aby go odbudować lub zaktualizować",
-"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Proszę wybrać Przyznana kwota, faktury i faktury Rodzaj numer w conajmniej jednym rzędzie",
-Please select Apply Discount On,Proszę wybrać Zastosuj RABAT,
-Please select BOM against item {0},Wybierz zestawienie materiałów w odniesieniu do pozycji {0},
-Please select BOM for Item in Row {0},Proszę wybrać LM dla pozycji w wierszu {0},
-Please select BOM in BOM field for Item {0},Proszę wybrać LM w dziedzinie BOM dla pozycji {0},
-Please select Category first,Proszę najpierw wybrać kategorię,
-Please select Charge Type first,Najpierw wybierz typ opłaty,
-Please select Company,Proszę wybrać firmę,
-Please select Company and Designation,Wybierz firmę i oznaczenie,
-Please select Company and Posting Date to getting entries,"Wybierz Firmę i Data księgowania, aby uzyskać wpisy",
-Please select Company first,Najpierw wybierz firmę,
-Please select Completion Date for Completed Asset Maintenance Log,Proszę wybrać opcję Data zakończenia dla ukończonego dziennika konserwacji zasobów,
-Please select Completion Date for Completed Repair,Proszę wybrać datę zakończenia naprawy zakończonej,
-Please select Course,Proszę wybrać Kurs,
-Please select Drug,Proszę wybrać lek,
-Please select Employee,Wybierz pracownika,
-Please select Existing Company for creating Chart of Accounts,Wybierz istniejący podmiot do tworzenia planu kont,
-Please select Healthcare Service,Wybierz Healthcare Service,
-"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Proszę wybrać produkt, gdzie &quot;Czy Pozycja Zdjęcie&quot; brzmi &quot;Nie&quot; i &quot;Czy Sales Item&quot; brzmi &quot;Tak&quot;, a nie ma innego Bundle wyrobów",
-Please select Maintenance Status as Completed or remove Completion Date,Wybierz Stan konserwacji jako Zakończony lub usuń datę ukończenia,
-Please select Party Type first,Wybierz typ pierwszy Party,
-Please select Patient,Proszę wybrać Pacjenta,
-Please select Patient to get Lab Tests,"Wybierz pacjenta, aby uzyskać testy laboratoryjne",
-Please select Posting Date before selecting Party,Proszę wybrać Data księgowania przed wybraniem Stronę,
-Please select Posting Date first,Najpierw wybierz zamieszczenia Data,
-Please select Price List,Wybierz Cennik,
-Please select Program,Proszę wybrać Program,
-Please select Qty against item {0},Wybierz Qty przeciwko pozycji {0},
-Please select Sample Retention Warehouse in Stock Settings first,Najpierw wybierz Sample Retention Warehouse w ustawieniach magazynowych,
-Please select Start Date and End Date for Item {0},Wybierz Datę Startu i Zakończenia dla elementu {0},
-Please select Student Admission which is mandatory for the paid student applicant,"Wybierz Wstęp studenta, który jest obowiązkowy dla płatnego studenta",
-Please select a BOM,Wybierz zestawienie materiałów,
-Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,"Wybierz partię dla elementu {0}. Nie można znaleźć pojedynczej partii, która spełnia ten wymóg",
-Please select a Company,Wybierz firmę,
-Please select a batch,Wybierz partię,
-Please select a csv file,Proszę wybrać plik .csv,
-Please select a field to edit from numpad,Proszę wybrać pole do edycji z numpadu,
-Please select a table,Proszę wybrać tabelę,
-Please select a valid Date,Proszę wybrać prawidłową datę,
-Please select a value for {0} quotation_to {1},Proszę wprowadzić wartość dla wyceny {0} {1},
-Please select a warehouse,Proszę wybrać magazyn,
-Please select at least one domain.,Wybierz co najmniej jedną domenę.,
-Please select correct account,Proszę wybrać prawidłową konto,
-Please select date,Proszę wybrać datę,
-Please select item code,Wybierz kod produktu,
-Please select month and year,Wybierz miesiąc i rok,
-Please select prefix first,Wybierz prefiks,
-Please select the Company,Wybierz firmę,
-Please select the Multiple Tier Program type for more than one collection rules.,Wybierz typ programu dla wielu poziomów dla więcej niż jednej reguły zbierania.,
-Please select the assessment group other than 'All Assessment Groups',Proszę wybrać grupę oceniającą inną niż &quot;Wszystkie grupy oceny&quot;,
-Please select the document type first,Najpierw wybierz typ dokumentu,
-Please select weekly off day,Wybierz tygodniowe dni wolne,
-Please select {0},Proszę wybrać {0},
-Please select {0} first,Proszę najpierw wybrać {0},
-Please set 'Apply Additional Discount On',Proszę ustawić &quot;Zastosuj dodatkowe zniżki na &#39;,
-Please set 'Asset Depreciation Cost Center' in Company {0},Proszę ustawić &quot;aktywa Amortyzacja Cost Center&quot; w towarzystwie {0},
-Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Proszę ustaw &#39;wpływ konto / strata na aktywach Spółki w unieszkodliwianie &quot;{0},
-Please set Account in Warehouse {0} or Default Inventory Account in Company {1},Ustaw konto w magazynie {0} lub domyślne konto zapasów w firmie {1},
-Please set B2C Limit in GST Settings.,Ustaw Limit B2C w Ustawieniach GST.,
-Please set Company,Proszę ustawić firmę,
-Please set Company filter blank if Group By is 'Company',"Proszę wyłączyć filtr firmy, jeśli Group By jest &quot;Company&quot;",
-Please set Default Payroll Payable Account in Company {0},Proszę ustawić domyślny Payroll konto płatne w Spółce {0},
-Please set Depreciation related Accounts in Asset Category {0} or Company {1},Proszę ustawić amortyzacyjny dotyczący Konta aktywów z kategorii {0} lub {1} Spółki,
-Please set Email Address,Proszę ustawić adres e-mail,
-Please set GST Accounts in GST Settings,Ustaw Konta GST w Ustawieniach GST,
-Please set Hotel Room Rate on {},Ustaw stawkę hotelową na {},
-Please set Number of Depreciations Booked,Proszę ustawić ilość amortyzacji zarezerwowano,
-Please set Unrealized Exchange Gain/Loss Account in Company {0},Ustaw niezrealizowane konto zysku / straty w firmie {0},
-Please set User ID field in an Employee record to set Employee Role,Proszę ustawić pole ID użytkownika w rekordzie pracownika do roli pracownika zestawu,
-Please set a default Holiday List for Employee {0} or Company {1},Proszę ustawić domyślnej listy wypoczynkowe dla pracowników {0} lub {1} firmy,
-Please set account in Warehouse {0},Ustaw konto w magazynie {0},
-Please set an active menu for Restaurant {0},Ustaw aktywne menu restauracji {0},
-Please set associated account in Tax Withholding Category {0} against Company {1},Ustaw powiązane konto w kategorii U źródła poboru podatku {0} względem firmy {1},
-Please set at least one row in the Taxes and Charges Table,Ustaw co najmniej jeden wiersz w tabeli Podatki i opłaty,
-Please set default Cash or Bank account in Mode of Payment {0},Proszę ustawić domyślne konto Gotówka lub Bank dla płatności typu {0},
-Please set default account in Salary Component {0},Proszę ustawić domyślne konto wynagrodzenia komponentu {0},
-Please set default customer in Restaurant Settings,Ustaw domyślnego klienta w Ustawieniach restauracji,
-Please set default template for Leave Approval Notification in HR Settings.,Ustaw domyślny szablon powiadomienia o pozostawieniu zatwierdzania w Ustawieniach HR.,
-Please set default template for Leave Status Notification in HR Settings.,Ustaw domyślny szablon dla Opuszczania powiadomienia o statusie w Ustawieniach HR.,
-Please set default {0} in Company {1},Proszę ustawić domyślny {0} w towarzystwie {1},
-Please set filter based on Item or Warehouse,Proszę ustawić filtr na podstawie pkt lub magazynie,
-Please set leave policy for employee {0} in Employee / Grade record,Ustaw zasadę urlopu dla pracownika {0} w rekordzie Pracownicy / stanowisko,
-Please set recurring after saving,Proszę ustawić cykliczne po zapisaniu,
-Please set the Company,Proszę ustawić firmę,
-Please set the Customer Address,Ustaw adres klienta,
-Please set the Date Of Joining for employee {0},Proszę ustawić datę dołączenia do pracownika {0},
-Please set the Default Cost Center in {0} company.,Ustaw domyślne miejsce powstawania kosztów w firmie {0}.,
-Please set the Email ID for the Student to send the Payment Request,"Proszę podać identyfikator e-mailowy studenta, aby wysłać żądanie płatności",
-Please set the Item Code first,Proszę najpierw ustawić kod pozycji,
-Please set the Payment Schedule,Ustaw harmonogram płatności,
-Please set the series to be used.,"Ustaw serię, która ma być używana.",
-Please set {0} for address {1},Ustaw {0} na adres {1},
-Please setup Students under Student Groups,Proszę ustawić Studentów w grupach studenckich,
-Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',"Podziel się swoją opinią na szkolenie, klikając link &quot;Szkolenia zwrotne&quot;, a następnie &quot;Nowy&quot;",
-Please specify Company,Sprecyzuj Firmę,
-Please specify Company to proceed,Sprecyzuj firmę aby przejść dalej,
-Please specify a valid 'From Case No.',,
-Please specify a valid Row ID for row {0} in table {1},Proszę podać poprawny identyfikator wiersz dla rzędu {0} w tabeli {1},
-Please specify at least one attribute in the Attributes table,Proszę zaznaczyć co najmniej jeden atrybut w tabeli atrybutów,
-Please specify currency in Company,Proszę określić walutę w Spółce,
-Please specify either Quantity or Valuation Rate or both,Podaj dokładnie Ilość lub Stawkę lub obie,
-Please specify from/to range,Proszę określić zakres od/do,
-Please supply the specified items at the best possible rates,Proszę dostarczyć określone przedmioty w najlepszych możliwych cenach,
-Please update your status for this training event,Proszę zaktualizować swój status w tym szkoleniu,
-Please wait 3 days before resending the reminder.,Poczekaj 3 dni przed ponownym wysłaniem przypomnienia.,
-Point of Sale,Punkt Sprzedaży (POS),
-Point-of-Sale,Punkt sprzedaży,
-Point-of-Sale Profile,Point-of-Sale profil,
-Portal,Portal,
-Portal Settings,Ustawienia,
-Possible Supplier,Dostawca możliwe,
-Postal Expenses,Wydatki pocztowe,
-Posting Date,Data publikacji,
-Posting Date cannot be future date,Data publikacji nie może być datą przyszłą,
-Posting Time,Czas publikacji,
-Posting date and posting time is mandatory,Delegowanie datę i czas delegowania jest obowiązkowe,
-Posting timestamp must be after {0},Datownik musi byś ustawiony przed {0},
-Potential opportunities for selling.,Potencjalne szanse na sprzedaż.,
-Practitioner Schedule,Harmonogram praktyk,
-Pre Sales,Przedsprzedaż,
-Preference,Pierwszeństwo,
-Prescribed Procedures,Zalecane procedury,
-Prescription,Recepta,
-Prescription Dosage,Dawka leku na receptę,
-Prescription Duration,Czas trwania recepty,
-Prescriptions,Recepty,
-Present,Obecny,
-Prev,Poprzedni,
-Preview,Podgląd,
-Preview Salary Slip,Podgląd Zarobki Slip,
-Previous Financial Year is not closed,Poprzedni rok finansowy nie jest zamknięta,
-Price,Cena,
-Price List,Cennik,
-Price List Currency not selected,Nie wybrano Cennika w Walucie,
-Price List Rate,Wartość w cenniku,
-Price List master.,Ustawienia Cennika.,
-Price List must be applicable for Buying or Selling,Cennik musi być przyporządkowany do kupna albo sprzedaży,
-Price List {0} is disabled or does not exist,Cennik {0} jest wyłączona lub nie istnieje,
-Price or product discount slabs are required,Wymagane są płyty cenowe lub rabatowe na produkty,
-Pricing,Ustalanie cen,
-Pricing Rule,Zasada ustalania cen,
-"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Wycena Zasada jest najpierw wybiera się na podstawie ""Zastosuj Na"" polu, które może być pozycja, poz Grupa lub Marka.",
-"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Wycena Zasada jest nadpisanie cennik / określenie procentowego rabatu, w oparciu o pewne kryteria.",
-Pricing Rule {0} is updated,Zaktualizowano regułę cenową {0},
-Pricing Rules are further filtered based on quantity.,Zasady ustalania cen są dalej filtrowane na podstawie ilości.,
-Primary Address Details,Podstawowe dane adresowe,
-Primary Contact Details,Podstawowe dane kontaktowe,
-Principal Amount,Główna kwota,
-Print Format,Format Druku,
-Print IRS 1099 Forms,Drukuj formularze IRS 1099,
-Print Report Card,Wydrukuj kartę raportu,
-Print Settings,Ustawienia drukowania,
-Print and Stationery,Druk i Materiały Biurowe,
-Print settings updated in respective print format,Ustawienia drukowania zaktualizowane w odpowiednim formacie druku,
-Print taxes with zero amount,Drukowanie podatków z zerową kwotą,
-Printing and Branding,Drukowanie i firmowanie,
-Private Equity,Kapitał prywatny,
-Privilege Leave,Nieobecność z przywileju,
-Probation,Wyrok lub staż,
-Probationary Period,Okres próbny,
-Procedure,Procedura,
-Process Day Book Data,Dane książki dnia procesu,
-Process Master Data,Przetwarzaj dane podstawowe,
-Processing Chart of Accounts and Parties,Przetwarzanie planu kont i stron,
-Processing Items and UOMs,Przetwarzanie elementów i UOM,
-Processing Party Addresses,Adresy stron przetwarzających,
-Processing Vouchers,Bony przetwarzające,
-Procurement,Zaopatrzenie,
-Produced Qty,Wytworzona ilość,
-Product,Produkt,
-Product Bundle,Pakiet produktów,
-Product Search,Wyszukiwarka produktów,
-Production,Produkcja,
-Production Item,Pozycja Produkcja,
-Products,Produkty,
-Profit and Loss,Zyski i Straty,
-Profit for the year,Zysk za rok,
-Program,Program,
-Program in the Fee Structure and Student Group {0} are different.,Program w strukturze opłat i grupa studencka {0} są różne.,
-Program {0} does not exist.,Program {0} nie istnieje.,
-Program: ,Program:,
-Progress % for a task cannot be more than 100.,Postęp% dla zadania nie może zawierać więcej niż 100.,
-Project Collaboration Invitation,Projekt zaproszenie Współpraca,
-Project Id,Projekt Id,
-Project Manager,Menadżer projektu,
-Project Name,Nazwa Projektu,
-Project Start Date,Data startu projektu,
-Project Status,Status projektu,
-Project Summary for {0},Podsumowanie projektu dla {0},
-Project Update.,Aktualizacja projektu.,
-Project Value,Wartość projektu,
-Project activity / task.,Czynność / zadanie projektu,
-Project master.,Dyrektor projektu,
-Project-wise data is not available for Quotation,,
-Projected,Prognozowany,
-Projected Qty,Przewidywana ilość,
-Projected Quantity Formula,Formuła przewidywanej ilości,
-Projects,Projekty,
-Property,Właściwość,
-Property already added,Właściwość została już dodana,
-Proposal Writing,Pisanie wniosku,
-Proposal/Price Quote,Propozycja/Oferta cenowa,
-Prospecting,Poszukiwania,
-Provisional Profit / Loss (Credit),Rezerwowy Zysk / Strata (Credit),
-Publications,Publikacje,
-Publish Items on Website,Publikowanie przedmioty na stronie internetowej,
-Published,Opublikowany,
-Publishing,Działalność wydawnicza,
-Purchase,Zakup,
-Purchase Amount,Kwota zakupu,
-Purchase Date,Data zakupu,
-Purchase Invoice,Faktura zakupu,
-Purchase Invoice {0} is already submitted,Faktura zakupu {0} została już wysłana,
-Purchase Manager,Menadżer Zakupów,
-Purchase Master Manager,Główny Menadżer Zakupów,
-Purchase Order,Zamówienie,
-Purchase Order Amount,Kwota zamówienia zakupu,
-Purchase Order Amount(Company Currency),Kwota zamówienia zakupu (waluta firmy),
-Purchase Order Date,Data zamówienia zakupu,
-Purchase Order Items not received on time,Elementy zamówienia zakupu nie zostały dostarczone na czas,
-Purchase Order number required for Item {0},Numer Zamówienia Kupna wymagany do {0},
-Purchase Order to Payment,Zamówienie zakupu do płatności,
-Purchase Order {0} is not submitted,Zamówienia Kupna {0} nie zostało wysłane,
-Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Zlecenia zakupu nie są dozwolone w {0} z powodu karty wyników {1}.,
-Purchase Orders given to Suppliers.,Zamówienia Kupna dane Dostawcom,
-Purchase Price List,Cennik zakupowy,
-Purchase Receipt,Potwierdzenie zakupu,
-Purchase Receipt {0} is not submitted,Potwierdzenie zakupu {0} nie zostało wysłane,
-Purchase Tax Template,Szablon podatkowy zakupów,
-Purchase User,Zakup użytkownika,
-Purchase orders help you plan and follow up on your purchases,Zamówienia pomoże Ci zaplanować i śledzić na zakupy,
-Purchasing,Dostawy,
-Purpose must be one of {0},Cel musi być jednym z {0},
-Qty,Ilość,
-Qty To Manufacture,Ilość do wyprodukowania,
-Qty Total,Ilość całkowita,
-Qty for {0},Ilość dla {0},
-Qualification,Kwalifikacja,
-Quality,Jakość,
-Quality Action,Akcja jakości,
-Quality Goal.,Cel jakości.,
-Quality Inspection,Kontrola jakości,
-Quality Inspection: {0} is not submitted for the item: {1} in row {2},Kontrola jakości: {0} nie jest przesyłany dla przedmiotu: {1} w wierszu {2},
-Quality Management,Zarządzanie jakością,
-Quality Meeting,Spotkanie jakościowe,
-Quality Procedure,Procedura jakości,
-Quality Procedure.,Procedura jakości.,
-Quality Review,Przegląd jakości,
-Quantity,Ilość,
-Quantity for Item {0} must be less than {1},Ilość dla przedmiotu {0} musi być mniejsza niż {1},
-Quantity in row {0} ({1}) must be same as manufactured quantity {2},Ilość w rzędzie  {0} ({1}) musi być taka sama jak wyprodukowana ilość {2},
-Quantity must be less than or equal to {0},Ilość musi być mniejsze niż lub równe {0},
-Quantity must not be more than {0},Ilość nie może być większa niż {0},
-Quantity required for Item {0} in row {1},Ilość wymagana dla Przedmiotu {0} w rzędzie {1},
-Quantity should be greater than 0,Ilość powinna być większa niż 0,
-Quantity to Make,Ilość do zrobienia,
-Quantity to Manufacture must be greater than 0.,Ilość do produkcji musi być większy niż 0 ° C.,
-Quantity to Produce,Ilość do wyprodukowania,
-Quantity to Produce can not be less than Zero,Ilość do wyprodukowania nie może być mniejsza niż zero,
-Query Options,Opcje Zapytania,
-Queued for replacing the BOM. It may take a few minutes.,W kolejce do zastąpienia BOM. Może to potrwać kilka minut.,
-Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Usługa kolejkowania aktualizacji najnowszej ceny we wszystkich materiałach. Może potrwać kilka minut.,
-Quick Journal Entry,Szybkie Księgowanie,
-Quot Count,Quot Count,
-Quot/Lead %,Kwota / kwota procentowa,
-Quotation,Wycena,
-Quotation {0} is cancelled,Oferta {0} jest anulowana,
-Quotation {0} not of type {1},Oferta {0} nie jest typem {1},
-Quotations,Notowania,
-"Quotations are proposals, bids you have sent to your customers","Notowania są propozycje, oferty Wysłane do klientów",
-Quotations received from Suppliers.,Wyceny otrzymane od dostawców,
-Quotations: ,Cytaty:,
-Quotes to Leads or Customers.,Wycena dla Tropów albo Klientów,
-RFQs are not allowed for {0} due to a scorecard standing of {1},Zlecenia RFQ nie są dozwolone w {0} z powodu karty wyników {1},
-Range,Przedział,
-Rate,Stawka,
-Rate:,Oceniać:,
-Rating,Ocena,
-Raw Material,Surowiec,
-Raw Materials,Surowy materiał,
-Raw Materials cannot be blank.,Surowce nie może być puste.,
-Re-open,Otwórz ponownie,
-Read blog,Czytaj blog,
-Read the ERPNext Manual,Przeczytać instrukcję ERPNext,
-Reading Uploaded File,Odczyt przesłanego pliku,
-Real Estate,Nieruchomości,
-Reason For Putting On Hold,Powód do zawieszenia,
-Reason for Hold,Powód wstrzymania,
-Reason for hold: ,Powód wstrzymania:,
-Receipt,Paragon,
-Receipt document must be submitted,Otrzymanie dokumentu należy składać,
-Receivable,Należności,
-Receivable Account,Konto Należności,
-Received,Otrzymano,
-Received On,Otrzymana w dniu,
-Received Quantity,Otrzymana ilość,
-Received Stock Entries,Otrzymane wpisy giełdowe,
-Receiver List is empty. Please create Receiver List,Lista odbiorców jest pusta. Proszę stworzyć Listę Odbiorców,
-Recipients,Adresaci,
-Reconcile,Uzgodnij,
-"Record of all communications of type email, phone, chat, visit, etc.","Zapis wszystkich komunikatów typu e-mail, telefon, czat, wizyty, itd",
-Records,Dokumentacja,
-Redirect URL,przekierowanie,
-Ref,Ref,
-Ref Date,Ref Data,
-Reference,Referencja,
-Reference #{0} dated {1},Odnośnik #{0} z datą {1},
-Reference Date,Data Odniesienia,
-Reference Doctype must be one of {0},Doctype referencyjny musi być jednym z {0},
-Reference Document,Dokument referencyjny,
-Reference Document Type,Oznaczenie typu dokumentu,
-Reference No & Reference Date is required for {0},Nr Odniesienia & Data Odniesienia jest wymagana do {0},
-Reference No and Reference Date is mandatory for Bank transaction,Numer referencyjny i data jest obowiązkowe dla transakcji Banku,
-Reference No is mandatory if you entered Reference Date,Nr Odniesienia jest obowiązkowy jest wprowadzono Datę Odniesienia,
-Reference No.,Nr referencyjny.,
-Reference Number,Numer Odniesienia,
-Reference Owner,Odniesienie Właściciel,
-Reference Type,Typ Odniesienia,
-"Reference: {0}, Item Code: {1} and Customer: {2}","Odniesienie: {0}, Kod pozycji: {1} i klient: {2}",
-References,Referencje,
-Refresh Token,Odśwież Reklamowe,
-Region,Region,
-Register,Zarejestrować,
-Reject,Odrzucać,
-Rejected,Odrzucono,
-Related,Związane z,
-Relation with Guardian1,Relacja z Guardian1,
-Relation with Guardian2,Relacja z Guardian2,
-Release Date,Data wydania,
-Reload Linked Analysis,Przeładuj połączoną analizę,
-Remaining,Pozostały,
-Remaining Balance,Pozostałe saldo,
-Remarks,Uwagi,
-Reminder to update GSTIN Sent,Przypomnienie o aktualizacji GSTIN wysłanych,
-Remove item if charges is not applicable to that item,"Usuń element, jeśli opłata nie ma zastosowania do tej pozycji",
-Removed items with no change in quantity or value.,Usunięte pozycje bez zmian w ilości lub wartości.,
-Reopen,Otworzyć na nowo,
-Reorder Level,Poziom Uporządkowania,
-Reorder Qty,Ilość do ponownego zamówienia,
-Repeat Customer Revenue,Powtórz Przychody klienta,
-Repeat Customers,Powtarzający się klient,
-Replace BOM and update latest price in all BOMs,Zastąp BOM i zaktualizuj ostatnią cenę we wszystkich materiałach,
-Replied,Odpowiedziane,
-Replies,Odpowiedzi,
-Report,Raport,
-Report Builder,Kreator raportów,
-Report Type,Typ raportu,
-Report Type is mandatory,Typ raportu jest wymagany,
-Reports,Raporty,
-Reqd By Date,Data realizacji,
-Reqd Qty,Wymagana ilość,
-Request for Quotation,Zapytanie ofertowe,
-Request for Quotations,Zapytanie o cenę,
-Request for Raw Materials,Zapytanie o surowce,
-Request for purchase.,Prośba o zakup,
-Request for quotation.,Zapytanie ofertowe.,
-Requested Qty,,
-"Requested Qty: Quantity requested for purchase, but not ordered.",,
-Requesting Site,Strona żądająca,
-Requesting payment against {0} {1} for amount {2},Żądanie zapłatę przed {0} {1} w ilości {2},
-Requestor,Żądający,
-Required On,Wymagane na,
-Required Qty,Wymagana ilość,
-Required Quantity,Wymagana ilość,
-Reschedule,Zmień harmonogram,
-Research,Badania,
-Research & Development,Badania i Rozwój,
-Researcher,Researcher,
-Resend Payment Email,Wyślij ponownie płatności E-mail,
-Reserve Warehouse,Reserve Warehouse,
-Reserved Qty,Zarezerwowana ilość,
-Reserved Qty for Production,Reserved Ilość Produkcji,
-Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Zarezerwowane Ilość na produkcję: Ilość surowców do produkcji artykułów.,
-"Reserved Qty: Quantity ordered for sale, but not delivered.",,
-Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Magazyn Reserved jest obowiązkowy dla Produktu {0} w dostarczonych Surowcach,
-Reserved for manufacturing,Zarezerwowana dla produkcji,
-Reserved for sale,Zarezerwowane na sprzedaż,
-Reserved for sub contracting,Zarezerwowany dla podwykonawców,
-Resistant,Odporny,
-Resolve error and upload again.,Rozwiąż błąd i prześlij ponownie.,
-Responsibilities,Obowiązki,
-Rest Of The World,Reszta świata,
-Restart Subscription,Ponownie uruchom subskrypcję,
-Restaurant,Restauracja,
-Result Date,Data wyniku,
-Result already Submitted,Wynik już przesłany,
-Resume,Wznawianie,
-Retail,Detal,
-Retail & Wholesale,Hurt i Detal,
-Retail Operations,Operacje detaliczne,
-Retained Earnings,Zysk z lat ubiegłych,
-Retention Stock Entry,Wpis do magazynu retencyjnego,
-Retention Stock Entry already created or Sample Quantity not provided,Wpis zapasu retencji już utworzony lub nie podano próbki próbki,
-Return,Powrót,
-Return / Credit Note,Powrót / Credit Note,
-Return / Debit Note,Powrót / noty obciążeniowej,
-Returns,zwroty,
-Reverse Journal Entry,Reverse Journal Entry,
-Review Invitation Sent,Wysłane zaproszenie do recenzji,
-Review and Action,Recenzja i działanie,
-Role,Rola,
-Rooms Booked,Pokoje zarezerwowane,
-Root Company,Firma główna,
-Root Type,Typ Root,
-Root Type is mandatory,Typ Root jest obowiązkowy,
-Root cannot be edited.,Root nie może być edytowany,
-Root cannot have a parent cost center,Root nie może mieć rodzica w centrum kosztów,
-Round Off,Zaokrąglenia,
-Rounded Total,Końcowa zaokrąglona kwota,
-Route,Trasa,
-Row # {0}: ,Wiersz # {0}:,
-Row # {0}: Batch No must be same as {1} {2},"Wiersz # {0}: Batch Nie musi być taki sam, jak {1} {2}",
-Row # {0}: Cannot return more than {1} for Item {2},Wiersz # {0}: Nie można wrócić więcej niż {1} dla pozycji {2},
-Row # {0}: Rate cannot be greater than the rate used in {1} {2},Wiersz {0}: stawka nie może być większa niż stawka stosowana w {1} {2},
-Row # {0}: Serial No is mandatory,Wiersz # {0}: Numer seryjny jest obowiązkowe,
-Row # {0}: Serial No {1} does not match with {2} {3},Wiersz # {0}: Numer seryjny: {1} nie jest zgodny z {2} {3},
-Row #{0} (Payment Table): Amount must be negative,Wiersz nr {0} (tabela płatności): kwota musi być ujemna,
-Row #{0} (Payment Table): Amount must be positive,Wiersz nr {0} (tabela płatności): kwota musi być dodatnia,
-Row #{0}: Account {1} does not belong to company {2},Wiersz nr {0}: konto {1} nie należy do firmy {2},
-Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Wiersz {0}: alokowana kwota nie może być większa niż kwota pozostająca do spłaty.,
-"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Wiersz # {0}: {1} aktywami nie mogą być składane, jest już {2}",
-Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,"Wiersz nr {0}: nie można ustawić wartości Rate, jeśli kwota jest większa niż kwota rozliczona dla elementu {1}.",
-Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Wiersz # {0}: Data Rozliczenie {1} nie może być wcześniejsza niż data Czek {2},
-Row #{0}: Duplicate entry in References {1} {2},Wiersz # {0}: Duplikuj wpis w odsyłaczach {1} {2},
-Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Wiersz # {0}: oczekiwana data dostarczenia nie może być poprzedzona datą zamówienia zakupu,
-Row #{0}: Item added,Wiersz # {0}: element dodany,
-Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Wiersz # {0}: Journal Entry {1} nie masz konta {2} lub już porównywana z innym kuponie,
-Row #{0}: Not allowed to change Supplier as Purchase Order already exists,"Wiersz # {0}: Nie wolno zmienić dostawcę, jak już istnieje Zamówienie",
-Row #{0}: Please set reorder quantity,Wiersz # {0}: Proszę ustawić ilość zmienić kolejność,
-Row #{0}: Please specify Serial No for Item {1},Wiersz # {0}: Proszę podać nr seryjny dla pozycji {1},
-Row #{0}: Qty increased by 1,Wiersz # {0}: Ilość zwiększona o 1,
-Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,"Wiersz # {0}: Cena musi być taki sam, jak {1}: {2} ({3} / {4})",
-Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Wiersz # {0}: Typ dokumentu referencyjnego musi być jednym z wydatków roszczenia lub wpisu do dziennika,
-"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Wiersz # {0}: Reference Document Type musi być jednym z Zamówieniem, faktura zakupu lub Journal Entry",
-Row #{0}: Rejected Qty can not be entered in Purchase Return,Wiersz # {0}: Odrzucone Ilość nie może być wprowadzone w Purchase Powrót,
-Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Wiersz # {0}: Odrzucone Magazyn jest obowiązkowe przed odrzucony poz {1},
-Row #{0}: Reqd by Date cannot be before Transaction Date,Wiersz nr {0}: Data realizacji nie może być wcześniejsza od daty transakcji,
-Row #{0}: Set Supplier for item {1},Wiersz # {0}: Ustaw Dostawca dla pozycji {1},
-Row #{0}: Status must be {1} for Invoice Discounting {2},Wiersz # {0}: status musi być {1} dla rabatu na faktury {2},
-"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Wiersz # {0}: partia {1} ma tylko {2} qty. Wybierz inną partię, która ma {3} qty dostępną lub podzielisz wiersz na wiele wierszy, aby dostarczyć / wydać z wielu partii",
-Row #{0}: Timings conflicts with row {1},Wiersz # {0}: taktowania konflikty z rzędu {1},
-Row #{0}: {1} can not be negative for item {2},Wiersz # {0}: {1} nie może być negatywne dla pozycji {2},
-Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Wiersz nr {0}: Kwota nie może być większa niż oczekiwaniu Kwota wobec Kosztów zastrzeżenia {1}. W oczekiwaniu Kwota jest {2},
-Row {0} : Operation is required against the raw material item {1},Wiersz {0}: operacja jest wymagana względem elementu surowcowego {1},
-Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Wiersz {0} # Przydzielona kwota {1} nie może być większa od kwoty nieodebranej {2},
-Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Wiersz {0} # Element {1} nie może zostać przeniesiony więcej niż {2} na zamówienie {3},
-Row {0}# Paid Amount cannot be greater than requested advance amount,Wiersz {0} # Płatna kwota nie może być większa niż żądana kwota zaliczki,
-Row {0}: Activity Type is mandatory.,Wiersz {0}: Typ aktywny jest obowiązkowe.,
-Row {0}: Advance against Customer must be credit,Wiersz {0}: Zaliczka  Klienta jest po stronie kredytowej,
-Row {0}: Advance against Supplier must be debit,Wiersz {0}: Zaliczka Dostawcy jest po stronie debetowej,
-Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Wiersz {0}: Przyznana kwota {1} musi być mniejsza lub równa kwocie Entry Płatność {2},
-Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Wiersz {0}: Przyznana kwota {1} musi być mniejsza lub równa pozostałej kwoty faktury {2},
-Row {0}: An Reorder entry already exists for this warehouse {1},"Wiersz {0}: Zapis ponownego zamawiania dla tego magazynu, {1}",
-Row {0}: Bill of Materials not found for the Item {1},Wiersz {0}: Bill of Materials nie znaleziono Item {1},
-Row {0}: Conversion Factor is mandatory,Wiersz {0}: Współczynnik konwersji jest obowiązkowe,
-Row {0}: Cost center is required for an item {1},Wiersz {0}: wymagany jest koszt centrum dla elementu {1},
-Row {0}: Credit entry can not be linked with a {1},Wiersz {0}: wejście kredytowe nie mogą być powiązane z {1},
-Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Wiersz {0}: Waluta BOM # {1} powinna być równa wybranej walucie {2},
-Row {0}: Debit entry can not be linked with a {1},Wiersz {0}: Debit wpis nie może być związana z {1},
-Row {0}: Depreciation Start Date is required,Wiersz {0}: Wymagana data rozpoczęcia amortyzacji,
-Row {0}: Enter location for the asset item {1},Wiersz {0}: wpisz lokalizację dla elementu zasobu {1},
-Row {0}: Exchange Rate is mandatory,Wiersz {0}: Kurs wymiany jest obowiązkowe,
-Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Wiersz {0}: oczekiwana wartość po przydatności musi być mniejsza niż kwota zakupu brutto,
-Row {0}: From Time and To Time is mandatory.,Wiersz {0}: od czasu do czasu i jest obowiązkowe.,
-Row {0}: From Time and To Time of {1} is overlapping with {2},Wiersz {0}: od czasu do czasu i od {1} pokrywa się z {2},
-Row {0}: From time must be less than to time,Wiersz {0}: Od czasu musi być mniej niż do czasu,
-Row {0}: Hours value must be greater than zero.,Wiersz {0}: Godziny wartość musi być większa od zera.,
-Row {0}: Invalid reference {1},Wiersz {0}: Nieprawidłowy odniesienia {1},
-Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Wiersz {0}: Party / konto nie jest zgodny z {1} / {2} w {3} {4},
-Row {0}: Party Type and Party is required for Receivable / Payable account {1},Wiersz {0}: Typ i Partia Partia jest wymagane w przypadku otrzymania / rachunku Płatne {1},
-Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Wiersz {0}: Płatność przeciwko sprzedaży / Zamówienia powinny być zawsze oznaczone jako góry,
-Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Wiersz {0}: Proszę sprawdzić ""Czy Advance"" przeciw konta {1}, jeśli jest to zaliczka wpis.",
-Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,Wiersz {0}: należy ustawić w Powodzie zwolnienia z podatku w podatkach od sprzedaży i opłatach,
-Row {0}: Please set the Mode of Payment in Payment Schedule,Wiersz {0}: ustaw tryb płatności w harmonogramie płatności,
-Row {0}: Please set the correct code on Mode of Payment {1},Wiersz {0}: ustaw prawidłowy kod w trybie płatności {1},
-Row {0}: Qty is mandatory,Wiersz {0}: Ilość jest obowiązkowe,
-Row {0}: Quality Inspection rejected for item {1},Wiersz {0}: Kontrola jakości odrzucona dla elementu {1},
-Row {0}: UOM Conversion Factor is mandatory,Wiersz {0}: JM Współczynnik konwersji jest obowiązkowe,
-Row {0}: select the workstation against the operation {1},Wiersz {0}: wybierz stację roboczą w stosunku do operacji {1},
-Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Wiersz {0}: {1} wymagane numery seryjne dla elementu {2}. Podałeś {3}.,
-Row {0}: {1} must be greater than 0,Wiersz {0}: {1} musi być większy niż 0,
-Row {0}: {1} {2} does not match with {3},Wiersz {0}: {1} {2} nie zgadza się z {3},
-Row {0}:Start Date must be before End Date,Wiersz {0}: Data Początku musi być przed Datą Końca,
-Rows with duplicate due dates in other rows were found: {0},Znaleziono wiersze z powtarzającymi się datami w innych wierszach: {0},
-Rules for adding shipping costs.,Zasady naliczania kosztów transportu.,
-Rules for applying pricing and discount.,Zasady określania cen i zniżek,
-S.O. No.,,
-SGST Amount,Kwota SGST,
-SO Qty,,
-Safety Stock,Bezpieczeństwo Zdjęcie,
-Salary,Wynagrodzenia,
-Salary Slip ID,Wynagrodzenie Slip ID,
-Salary Slip of employee {0} already created for this period,Wynagrodzenie Slip pracownika {0} już stworzony dla tego okresu,
-Salary Slip of employee {0} already created for time sheet {1},Slip Wynagrodzenie pracownika {0} już stworzony dla arkusza czasu {1},
-Salary Slip submitted for period from {0} to {1},Przesłane wynagrodzenie za okres od {0} do {1},
-Salary Structure Assignment for Employee already exists,Przydział struktury wynagrodzeń dla pracownika już istnieje,
-Salary Structure Missing,Struktura Wynagrodzenie Brakujący,
-Salary Structure must be submitted before submission of Tax Ememption Declaration,Struktura wynagrodzeń musi zostać złożona przed złożeniem deklaracji zwolnienia podatkowego,
-Salary Structure not found for employee {0} and date {1},Nie znaleziono struktury wynagrodzenia dla pracownika {0} i daty {1},
-Salary Structure should have flexible benefit component(s) to dispense benefit amount,Struktura wynagrodzeń powinna mieć elastyczny składnik (-y) świadczeń w celu przyznania kwoty świadczenia,
-"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.",Wynagrodzenie już przetwarzane w okresie od {0} i {1} Zostaw okresu stosowania nie może być pomiędzy tym zakresie dat.,
-Sales,Sprzedaż,
-Sales Account,Konto sprzedaży,
-Sales Expenses,Koszty sprzedaży,
-Sales Funnel,Lejek sprzedaży,
-Sales Invoice,Faktura sprzedaży,
-Sales Invoice {0} has already been submitted,Faktura Sprzedaży {0} została już wprowadzona,
-Sales Invoice {0} must be cancelled before cancelling this Sales Order,Faktura Sprzedaży {0} powinna być anulowana przed anulowaniem samego Zlecenia Sprzedaży,
-Sales Manager,Menadżer Sprzedaży,
-Sales Master Manager,Główny Menadżer Sprzedaży,
-Sales Order,Zlecenie sprzedaży,
-Sales Order Item,Pozycja Zlecenia Sprzedaży,
-Sales Order required for Item {0},Zlecenie Sprzedaży jest wymagane dla Elementu {0},
-Sales Order to Payment,Płatności do zamówienia sprzedaży,
-Sales Order {0} is not submitted,Zlecenie Sprzedaży {0} nie jest jeszcze złożone,
-Sales Order {0} is not valid,Zlecenie Sprzedaży {0} jest niepoprawne,
-Sales Order {0} is {1},Zamówienie sprzedaży jest {0} {1},
-Sales Orders,Zlecenia sprzedaży,
-Sales Partner,Partner Sprzedaży,
-Sales Pipeline,Pipeline sprzedaży,
-Sales Price List,Lista cena sprzedaży,
-Sales Return,Zwrot sprzedaży,
-Sales Summary,Podsumowanie sprzedaży,
-Sales Tax Template,Szablon Podatek od sprzedaży,
-Sales Team,Team Sprzedażowy,
-Sales User,Sprzedaż użytkownika,
-Sales and Returns,Sprzedaż i zwroty,
-Sales campaigns.,Kampanie sprzedażowe,
-Sales orders are not available for production,Zamówienia sprzedaży nie są dostępne do produkcji,
-Salutation,Forma grzecznościowa,
-Same Company is entered more than once,Ta sama Spółka wpisana jest więcej niż jeden raz,
-Same item cannot be entered multiple times.,Sama pozycja nie może być wprowadzone wiele razy.,
-Same supplier has been entered multiple times,"Tego samego dostawcy, który został wpisany wielokrotnie",
-Sample,Próba,
-Sample Collection,Kolekcja próbek,
-Sample quantity {0} cannot be more than received quantity {1},Ilość próbki {0} nie może być większa niż ilość odebranej {1},
-Sanctioned,usankcjonowane,
-Sanctioned Amount,Zatwierdzona Kwota,
-Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Usankcjonowane Kwota nie może być większa niż ilość roszczenia w wierszu {0}.,
-Sand,Piasek,
-Saturday,Sobota,
-Saved,Zapisane,
-Saving {0},Zapisywanie {0},
-Scan Barcode,Skanuj kod kreskowy,
-Schedule,Harmonogram,
-Schedule Admission,Zaplanuj wstęp,
-Schedule Course,Plan zajęć,
-Schedule Date,Planowana Data,
-Schedule Discharge,Zaplanuj rozładowanie,
-Scheduled,Zaplanowane,
-Scheduled Upto,Zaplanowane Upto,
-"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Harmonogramy nakładek {0}, czy chcesz kontynuować po przejściu przez zakładki?",
-Score cannot be greater than Maximum Score,Wynik nie może być większa niż maksymalna liczba punktów,
-Score must be less than or equal to 5,Wynik musi być niższy lub równy 5,
-Scorecards,Karty wyników,
-Scrapped,Złomowany,
-Search,Szukaj,
-Search Results,Wyniki wyszukiwania,
-Search Sub Assemblies,Zespoły Szukaj Sub,
-"Search by item code, serial number, batch no or barcode","Wyszukaj według kodu produktu, numeru seryjnego, numeru partii lub kodu kreskowego",
-"Seasonality for setting budgets, targets etc.","Sezonowość ustalania budżetów, cele itd.",
-Secret Key,Sekretny klucz,
-Secretary,Sekretarka,
-Section Code,Kod sekcji,
-Secured Loans,Kredyty Hipoteczne,
-Securities & Commodity Exchanges,Papiery i Notowania Giełdowe,
-Securities and Deposits,Papiery wartościowe i depozyty,
-See All Articles,Zobacz wszystkie artykuły,
-See all open tickets,Zobacz wszystkie otwarte bilety,
-See past orders,Zobacz poprzednie zamówienia,
-See past quotations,Zobacz poprzednie cytaty,
-Select,Wybierz,
-Select Alternate Item,Wybierz opcję Alternatywny przedmiot,
-Select Attribute Values,Wybierz wartości atrybutów,
-Select BOM,Wybierz BOM,
-Select BOM and Qty for Production,Wybierz BOM i ilosc Produkcji,
-"Select BOM, Qty and For Warehouse","Wybierz LM, ilość i magazyn",
-Select Batch,Wybierz opcję Batch,
-Select Batch Numbers,Wybierz numery partii,
-Select Brand...,Wybierz markę ...,
-Select Company,Wybierz firmę,
-Select Company...,Wybierz firmą ...,
-Select Customer,Wybierz klienta,
-Select Days,Wybierz dni,
-Select Default Supplier,Wybierz Domyślne Dostawca,
-Select DocType,Wybierz DocType,
-Select Fiscal Year...,Wybierz rok finansowy ...,
-Select Item (optional),Wybierz pozycję (opcjonalnie),
-Select Items based on Delivery Date,Wybierz pozycje w oparciu o datę dostarczenia,
-Select Items to Manufacture,Wybierz produkty do Manufacture,
-Select Loyalty Program,Wybierz program lojalnościowy,
-Select Patient,Wybierz pacjenta,
-Select Possible Supplier,Wybierz Możliwa Dostawca,
-Select Property,Wybierz właściwość,
-Select Quantity,Wybierz ilość,
-Select Serial Numbers,Wybierz numery seryjne,
-Select Target Warehouse,Wybierz Magazyn docelowy,
-Select Warehouse...,Wybierz magazyn ...,
-Select an account to print in account currency,Wybierz konto do wydrukowania w walucie konta,
-Select an employee to get the employee advance.,"Wybierz pracownika, aby uzyskać awans pracownika.",
-Select at least one value from each of the attributes.,Wybierz co najmniej jedną wartość z każdego z atrybutów.,
-Select change amount account,Wybierz opcję Zmień konto kwotę,
-Select company first,Najpierw wybierz firmę,
-Select students manually for the Activity based Group,Wybierz uczniów ręcznie dla grupy działań,
-Select the customer or supplier.,Wybierz klienta lub dostawcę.,
-Select the nature of your business.,Wybierz charakteru swojej działalności.,
-Select the program first,Najpierw wybierz program,
-Select to add Serial Number.,"Wybierz, aby dodać numer seryjny.",
-Select your Domains,Wybierz swoje domeny,
-Selected Price List should have buying and selling fields checked.,Wybrany cennik powinien mieć sprawdzone pola kupna i sprzedaży.,
-Sell,Sprzedać,
-Selling,Sprzedaż,
-Selling Amount,Kwota sprzedaży,
-Selling Price List,Cennik sprzedaży,
-Selling Rate,Kurs sprzedaży,
-"Selling must be checked, if Applicable For is selected as {0}","Sprzedaż musi być sprawdzona, jeśli dotyczy wybrano jako {0}",
-Send Grant Review Email,Wyślij wiadomość e-mail dotyczącą oceny grantu,
-Send Now,Wyślij teraz,
-Send SMS,Wyślij SMS,
-Send mass SMS to your contacts,Wyślij zbiorczo sms do swoich kontaktów,
-Sensitivity,Wrażliwość,
-Sent,Wysłano,
-Serial No and Batch,Numer seryjny oraz Batch,
-Serial No is mandatory for Item {0},Nr seryjny jest obowiązkowy dla pozycji {0},
-Serial No {0} does not belong to Batch {1},Numer seryjny {0} nie należy do partii {1},
-Serial No {0} does not belong to Delivery Note {1},Nr seryjny {0} nie należy do żadnego potwierdzenia dostawy {1},
-Serial No {0} does not belong to Item {1},Nr seryjny {0} nie należy do żadnej rzeczy {1},
-Serial No {0} does not belong to Warehouse {1},Nr seryjny {0} nie należy do magazynu {1},
-Serial No {0} does not belong to any Warehouse,Nr seryjny: {0} nie należy do żadnego Magazynu,
-Serial No {0} does not exist,Nr seryjny {0} nie istnieje,
-Serial No {0} has already been received,Nr seryjny {0} otrzymano,
-Serial No {0} is under maintenance contract upto {1},Nr seryjny {0} w ramach umowy serwisowej do {1},
-Serial No {0} is under warranty upto {1},Nr seryjny {0} w ramach gwarancji do {1},
-Serial No {0} not found,Nr seryjny {0} nie znaleziono,
-Serial No {0} not in stock,,
-Serial No {0} quantity {1} cannot be a fraction,Nr seryjny {0} dla ilości {1} nie może być ułamkiem,
-Serial Nos Required for Serialized Item {0},Nr-y seryjne Wymagane do szeregowania pozycji {0},
-Serial Number: {0} is already referenced in Sales Invoice: {1},Numer seryjny: {0} znajduje się już w fakturze sprzedaży: {1},
-Serial Numbers,Numer seryjny,
-Serial Numbers in row {0} does not match with Delivery Note,Numery seryjne w wierszu {0} nie pasują do opisu dostawy,
-Serial no {0} has been already returned,Numer seryjny {0} został już zwrócony,
-Serial number {0} entered more than once,Nr seryjny {0} wprowadzony jest więcej niż jeden raz,
-Serialized Inventory,Inwentaryzacja w odcinkach,
-Series Updated,Aktualizacja serii,
-Series Updated Successfully,Seria zaktualizowana,
-Series is mandatory,Serie jest obowiązkowa,
-Series {0} already used in {1},Seria {0} już zostały użyte w {1},
-Service,Usługa,
-Service Expense,Koszty usługi,
-Service Level Agreement,Umowa o poziomie usług,
-Service Level Agreement.,Umowa o poziomie usług.,
-Service Level.,Poziom usług.,
-Service Stop Date cannot be after Service End Date,Data zatrzymania usługi nie może być późniejsza niż data zakończenia usługi,
-Service Stop Date cannot be before Service Start Date,Data zatrzymania usługi nie może być wcześniejsza niż data rozpoczęcia usługi,
-Services,Usługi,
-"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Ustaw wartości domyślne jak firma, waluta, bieżący rok rozliczeniowy, itd.",
-Set Details,Ustaw szczegóły,
-Set New Release Date,Ustaw nową datę wydania,
-Set Project and all Tasks to status {0}?,Ustaw projekt i wszystkie zadania na status {0}?,
-Set Status,Ustaw status,
-Set Tax Rule for shopping cart,Ustaw regułę podatkowa do koszyka,
-Set as Closed,Ustaw jako Zamknięty,
-Set as Completed,Ustaw jako ukończone,
-Set as Default,Ustaw jako domyślne,
-Set as Lost,Ustaw jako utracony,
-Set as Open,Ustaw jako otwarty,
-Set default inventory account for perpetual inventory,Ustaw domyślne konto zapasów dla zasobów reklamowych wieczystych,
-Set this if the customer is a Public Administration company.,"Ustaw to, jeśli klient jest firmą administracji publicznej.",
-Set {0} in asset category {1} or company {2},Ustaw {0} w kategorii aktywów {1} lub firmie {2},
-"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Ustawianie zdarzenia do {0}, ponieważ urzędnik dołączone do sprzedaży poniżej osób nie posiada identyfikator użytkownika {1}",
-Setting defaults,Ustawianie wartości domyślnych,
-Setting up Email,Konfiguracja e-mail,
-Setting up Email Account,Konfigurowanie konta e-mail,
-Setting up Employees,Ustawienia pracowników,
-Setting up Taxes,Konfigurowanie podatki,
-Setting up company,Zakładanie firmy,
-Settings,Ustawienia,
-"Settings for online shopping cart such as shipping rules, price list etc.","Ustawienia dla internetowego koszyka, takie jak zasady żeglugi, cennika itp",
-Settings for website homepage,Ustawienia strony głównej,
-Settings for website product listing,Ustawienia listy produktów w witrynie,
-Settled,Osiadły,
-Setup Gateway accounts.,Rachunki konfiguracji bramy.,
-Setup SMS gateway settings,Konfiguracja ustawień bramki SMS,
-Setup cheque dimensions for printing,Wymiary Sprawdź konfigurację do druku,
-Setup default values for POS Invoices,Ustaw wartości domyślne dla faktur POS,
-Setup mode of POS (Online / Offline),Tryb konfiguracji POS (Online / Offline),
-Setup your Institute in ERPNext,Skonfiguruj swój instytut w ERPNext,
-Share Balance,Udostępnij saldo,
-Share Ledger,Udostępnij Księgę,
-Share Management,Zarządzanie udziałami,
-Share Transfer,Udostępnij przelew,
-Share Type,Rodzaj udziału,
-Shareholder,Akcjonariusz,
-Ship To State,Ship To State,
-Shipments,Przesyłki,
-Shipping,Wysyłka,
-Shipping Address,Adres dostawy,
-"Shipping Address does not have country, which is required for this Shipping Rule","Adres wysyłki nie ma kraju, który jest wymagany dla tej reguły wysyłki",
-Shipping rule only applicable for Buying,Zasada wysyłki ma zastosowanie tylko do zakupów,
-Shipping rule only applicable for Selling,Reguła wysyłki dotyczy tylko sprzedaży,
-Shopify Supplier,Shopify dostawca,
-Shopping Cart,Koszyk,
-Shopping Cart Settings,Ustawienia koszyka,
-Short Name,Skrócona nazwa,
-Shortage Qty,Niedobór szt,
-Show Completed,Pokaż ukończone,
-Show Cumulative Amount,Pokaż łączną kwotę,
-Show Employee,Pokaż pracownika,
-Show Open,Pokaż otwarta,
-Show Opening Entries,Pokaż otwierające wpisy,
-Show Payment Details,Pokaż szczegóły płatności,
-Show Return Entries,Pokaż wpisy zwrotne,
-Show Salary Slip,Slip Pokaż Wynagrodzenie,
-Show Variant Attributes,Pokaż atrybuty wariantu,
-Show Variants,Pokaż warianty,
-Show closed,Pokaż closed,
-Show exploded view,Pokaż widok rozstrzelony,
-Show only POS,Pokaż tylko POS,
-Show unclosed fiscal year's P&L balances,Pokaż niezamkniętych rok obrotowy za P &amp; L sald,
-Show zero values,Pokaż wartości zerowe,
-Sick Leave,Urlop Chorobowy,
-Silt,Muł,
-Single Variant,Pojedynczy wariant,
-Single unit of an Item.,Jednostka produktu.,
-"Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}","Pomijanie Zostaw alokację dla następujących pracowników, ponieważ rekordy Urlop alokacji już istnieją przeciwko nim. {0}",
-"Skipping Salary Structure Assignment for the following employees, as Salary Structure Assignment records already exists against them. {0}","Pomijanie przydziału struktury wynagrodzeń dla następujących pracowników, ponieważ rekordy przypisania struktury wynagrodzeń już istnieją przeciwko nim. {0}",
-Slideshow,Pokaz slajdów,
-Slots for {0} are not added to the schedule,Gniazda dla {0} nie są dodawane do harmonogramu,
-Small,Mały,
-Soap & Detergent,Środki czystości i Detergenty,
-Software,Oprogramowanie,
-Software Developer,Programista,
-Softwares,Oprogramowania,
-Soil compositions do not add up to 100,Składy gleby nie sumują się do 100,
-Sold,Sprzedany,
-Some emails are invalid,Niektóre e-maile są nieprawidłowe,
-Some information is missing,Niektóre informacje brakuje,
-Something went wrong!,Coś poszło nie tak!,
-"Sorry, Serial Nos cannot be merged","Niestety, numery seryjne nie mogą zostać połączone",
-Source,Źródło,
-Source Name,Źródło Nazwa,
-Source Warehouse,Magazyn źródłowy,
-Source and Target Location cannot be same,Lokalizacja źródłowa i docelowa nie może być taka sama,
-Source and target warehouse cannot be same for row {0},Źródło i magazyn docelowy nie mogą być takie sama dla wiersza {0},
-Source and target warehouse must be different,Źródło i magazyn docelowy musi być inna,
-Source of Funds (Liabilities),Zobowiązania,
-Source warehouse is mandatory for row {0},Magazyn źródłowy jest obowiązkowy dla wiersza {0},
-Specified BOM {0} does not exist for Item {1},Określone BOM {0} nie istnieje dla pozycji {1},
-Split,Rozdzielać,
-Split Batch,Podział partii,
-Split Issue,Podziel problem,
-Sports,Sporty,
-Staffing Plan {0} already exist for designation {1},Plan zatrudnienia {0} już istnieje dla wyznaczenia {1},
-Standard,Standard,
-Standard Buying,Standardowe zakupy,
-Standard Selling,Standard sprzedaży,
-Standard contract terms for Sales or Purchase.,Standardowe warunki umowy sprzedaży lub kupna.,
-Start Date,Data startu,
-Start Date of Agreement can't be greater than or equal to End Date.,Data rozpoczęcia umowy nie może być większa lub równa dacie zakończenia.,
-Start Year,Rok rozpoczęcia,
-"Start and end dates not in a valid Payroll Period, cannot calculate {0}","Daty rozpoczęcia i zakończenia nie w ważnym okresie płacowym, nie można obliczyć {0}",
-"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Daty rozpoczęcia i zakończenia nie są w ważnym okresie rozliczeniowym, nie można obliczyć {0}.",
-Start date should be less than end date for Item {0},Data startu powinna być niższa od daty końca dla {0},
-Start date should be less than end date for task {0},Data rozpoczęcia powinna być mniejsza niż data zakończenia dla zadania {0},
-Start day is greater than end day in task '{0}',Dzień rozpoczęcia jest większy niż dzień zakończenia w zadaniu &quot;{0}&quot;,
-Start on,Zaczynaj na,
-State,Stan,
-State/UT Tax,Podatek stanowy / UT,
-Statement of Account,Wyciąg z rachunku,
-Status must be one of {0},Status musi być jednym z {0},
-Stock,Magazyn,
-Stock Adjustment,Korekta,
-Stock Analytics,Analityka magazynu,
-Stock Assets,Zapasy,
-Stock Available,Dostępność towaru,
-Stock Balance,Bilans zapasów,
-Stock Entries already created for Work Order ,Wpisy magazynowe już utworzone dla zlecenia pracy,
-Stock Entry,Zapis magazynowy,
-Stock Entry {0} created,Wpis {0} w Magazynie został utworzony,
-Stock Entry {0} is not submitted,Zdjęcie Wejście {0} nie jest składany,
-Stock Expenses,Wydatki magazynowe,
-Stock In Hand,Na stanie magazynu,
-Stock Items,produkty seryjne,
-Stock Ledger,Księga zapasów,
-Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Zapisy księgi zapasów oraz księgi głównej są odświeżone dla wybranego dokumentu zakupu,
-Stock Levels,Poziom zapasów,
-Stock Liabilities,Zadłużenie zapasów,
-Stock Options,Opcje magazynu,
-Stock Qty,Ilość zapasów,
-Stock Received But Not Billed,"Przyjęte na stan, nie zapłacone (zobowiązanie)",
-Stock Reports,Raporty seryjne,
-Stock Summary,Podsumowanie Zdjęcie,
-Stock Transactions,Operacje magazynowe,
-Stock UOM,Jednostka,
-Stock Value,Wartość zapasów,
-Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Saldo Zdjęcie w serii {0} będzie negatywna {1} dla pozycji {2} w hurtowni {3},
-Stock cannot be updated against Delivery Note {0},,
-Stock cannot be updated against Purchase Receipt {0},Zdjęcie nie może zostać zaktualizowany przed ZAKUPU {0},
-Stock cannot exist for Item {0} since has variants,"Zdjęcie nie może istnieć dla pozycji {0}, ponieważ ma warianty",
-Stock transactions before {0} are frozen,Operacje magazynowe przed {0} są zamrożone,
-Stop,Zatrzymaj,
-Stopped,Zatrzymany,
-"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Zatwierdzone zlecenie pracy nie może zostać anulowane, należy je najpierw anulować, aby anulować",
-Stores,Sklepy,
-Structures have been assigned successfully,Struktury zostały pomyślnie przypisane,
-Student,Student,
-Student Activity,Działalność uczniowska,
-Student Address,Adres studenta,
-Student Admissions,Rekrutacja dla studentów,
-Student Attendance,Obecność Studenta,
-"Student Batches help you track attendance, assessments and fees for students","Partie studenckich pomóc śledzenie obecności, oceny i opłat dla studentów",
-Student Email Address,Student adres email,
-Student Email ID,Student ID email,
-Student Group,Grupa Student,
-Student Group Strength,Siła grupy studentów,
-Student Group is already updated.,Grupa studentów jest już aktualizowana.,
-Student Group: ,Grupa studencka:,
-Student ID,legitymacja studencka,
-Student ID: ,Legitymacja studencka:,
-Student LMS Activity,Aktywność LMS studenta,
-Student Mobile No.,Nie Student Komórka,
-Student Name,Nazwa Student,
-Student Name: ,Imię ucznia:,
-Student Report Card,Karta zgłoszenia ucznia,
-Student is already enrolled.,Student jest już zarejestrowany.,
-Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} pojawia się wielokrotnie w wierszu {2} i {3},
-Student {0} does not belong to group {1},Student {0} nie należy do grupy {1},
-Student {0} exist against student applicant {1},Student {0} istnieć przed studenta wnioskodawcy {1},
-"Students are at the heart of the system, add all your students","Studenci są w samym sercu systemu, dodanie wszystkich swoich uczniów",
-Sub Assemblies,Komponenty,
-Sub Type,Podtyp,
-Sub-contracting,Podwykonawstwo,
-Subcontract,Zlecenie,
-Subject,Temat,
-Submit,Zatwierdź,
-Submit Proof,Prześlij dowód,
-Submit Salary Slip,Zatwierdź potrącenie z pensji,
-Submit this Work Order for further processing.,Prześlij to zlecenie pracy do dalszego przetwarzania.,
-Submit this to create the Employee record,"Prześlij to, aby utworzyć rekord pracownika",
-Submitting Salary Slips...,Przesyłanie wynagrodzeń ...,
-Subscription,Subskrypcja,
-Subscription Management,Zarządzanie subskrypcjami,
-Subscriptions,Subskrypcje,
-Subtotal,Razem,
-Successful,Udany,
-Successfully Reconciled,Pomyślnie uzgodnione,
-Successfully Set Supplier,Pomyślnie ustaw dostawcę,
-Successfully created payment entries,Pomyślnie utworzono wpisy płatności,
-Successfully deleted all transactions related to this company!,Pomyślnie usunięte wszystkie transakcje związane z tą firmą!,
-Sum of Scores of Assessment Criteria needs to be {0}.,Suma punktów kryteriów oceny musi być {0}.,
-Sum of points for all goals should be 100. It is {0},Suma punktów dla wszystkich celów powinno być 100. {0},
-Summary,Podsumowanie,
-Summary for this month and pending activities,Podsumowanie dla tego miesiąca i działań toczących,
-Summary for this week and pending activities,Podsumowanie na ten tydzień i działań toczących,
-Sunday,Niedziela,
-Suplier,Suplier,
-Supplier,Dostawca,
-Supplier Group,Grupa dostawców,
-Supplier Group master.,Mistrz grupy dostawców.,
-Supplier Id,ID Dostawcy,
-Supplier Invoice Date cannot be greater than Posting Date,Faktura dostawca Data nie może być większe niż Data publikacji,
-Supplier Invoice No,Nr faktury dostawcy,
-Supplier Invoice No exists in Purchase Invoice {0},Dostawca Faktura Nie istnieje faktura zakupu {0},
-Supplier Name,Nazwa dostawcy,
-Supplier Part No,Dostawca Część nr,
-Supplier Quotation,Oferta dostawcy,
-Supplier Scorecard,Karta wyników dostawcy,
-Supplier Warehouse mandatory for sub-contracted Purchase Receipt,,
-Supplier database.,Baza dostawców,
-Supplier {0} not found in {1},Dostawca {0} nie został znaleziony w {1},
-Supplier(s),Dostawca(y),
-Supplies made to UIN holders,Materiały dla posiadaczy UIN,
-Supplies made to Unregistered Persons,Dostawy dla niezarejestrowanych osób,
-Suppliies made to Composition Taxable Persons,Dodatki do osób podlegających opodatkowaniu,
-Supply Type,Rodzaj dostawy,
-Support,Wsparcie,
-Support Analytics,,
-Support Settings,Ustawienia wsparcia,
-Support Tickets,Bilety na wsparcie,
-Support queries from customers.,Zapytania klientów o wsparcie techniczne,
-Susceptible,Podatny,
-Sync has been temporarily disabled because maximum retries have been exceeded,"Synchronizacja została tymczasowo wyłączona, ponieważ przekroczono maksymalną liczbę ponownych prób",
-Syntax error in condition: {0},Błąd składni w warunku: {0},
-Syntax error in formula or condition: {0},Błąd składni we wzorze lub stanu: {0},
-System Manager,System Manager,
-TDS Rate %,Współczynnik TDS%,
-Tap items to add them here,"Dotknij elementów, aby je dodać tutaj",
-Target,Cel,
-Target ({}),Cel ({}),
-Target On,,
-Target Warehouse,Magazyn docelowy,
-Target warehouse is mandatory for row {0},Magazyn docelowy jest obowiązkowy dla wiersza {0},
-Task,Zadanie,
-Tasks,Zadania,
-Tasks have been created for managing the {0} disease (on row {1}),Utworzono zadania do zarządzania chorobą {0} (w wierszu {1}),
-Tax,Podatek,
-Tax Assets,Podatek należny (zwrot),
-Tax Category,Kategoria podatku,
-Tax Category for overriding tax rates.,Kategoria podatkowa za nadrzędne stawki podatkowe.,
-"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Kategoria podatkowa została zmieniona na &quot;Razem&quot;, ponieważ wszystkie elementy są towarami nieruchoma",
-Tax ID,Numer identyfikacji podatkowej (NIP),
-Tax Id: ,Identyfikator podatkowy:,
-Tax Rate,Stawka podatku,
-Tax Rule Conflicts with {0},Konflikty przepisu podatkowego z {0},
-Tax Rule for transactions.,Reguła podatkowa dla transakcji.,
-Tax Template is mandatory.,Szablon podatków jest obowiązkowy.,
-Tax Withholding rates to be applied on transactions.,Stawki podatku u źródła stosowane do transakcji.,
-Tax template for buying transactions.,Szablon podatków dla transakcji zakupu.,
-Tax template for item tax rates.,Szablon podatku dla stawek podatku od towarów.,
-Tax template for selling transactions.,Szablon podatków dla transakcji sprzedaży.,
-Taxable Amount,Kwota podlegająca opodatkowaniu,
-Taxes,Podatki,
-Team Updates,Aktualizacje zespół,
-Technology,Technologia,
-Telecommunications,Telekomunikacja,
-Telephone Expenses,Wydatki telefoniczne,
-Television,Telewizja,
-Template Name,Nazwa szablonu,
-Template of terms or contract.,Szablon z warunkami lub umową.,
-Templates of supplier scorecard criteria.,Szablony kryteriów oceny dostawców.,
-Templates of supplier scorecard variables.,Szablony dostawców zmiennych.,
-Templates of supplier standings.,Szablony standings dostawców.,
-Temporarily on Hold,Chwilowo zawieszone,
-Temporary,Tymczasowy,
-Temporary Accounts,Rachunki tymczasowe,
-Temporary Opening,Tymczasowe otwarcia,
-Terms and Conditions,Regulamin,
-Terms and Conditions Template,Szablony warunków i regulaminów,
-Territory,Region,
-Test,Test,
-Thank you,Dziękuję,
-Thank you for your business!,Dziękuję dla Twojej firmy!,
-The 'From Package No.' field must neither be empty nor it's value less than 1.,The &#39;From Package No.&#39; pole nie może być puste ani jego wartość mniejsza niż 1.,
-The Brand,Marka,
-The Item {0} cannot have Batch,Element {0} nie może mieć Batch,
-The Loyalty Program isn't valid for the selected company,Program lojalnościowy nie jest ważny dla wybranej firmy,
-The Payment Term at row {0} is possibly a duplicate.,Termin płatności w wierszu {0} jest prawdopodobnie duplikatem.,
-The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Termin Data zakończenia nie może być wcześniejsza niż data początkowa Term. Popraw daty i spróbuj ponownie.,
-The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Termin Data zakończenia nie może być późniejsza niż data zakończenia roku na rok akademicki, którego termin jest związany (Academic Year {}). Popraw daty i spróbuj ponownie.",
-The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Termin Data rozpoczęcia nie może być krótszy niż rok od daty rozpoczęcia roku akademickiego, w jakim termin ten jest powiązany (Academic Year {}). Popraw daty i spróbuj ponownie.",
-The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Rok Data zakończenia nie może być wcześniejsza niż data początkowa rok. Popraw daty i spróbuj ponownie.,
-The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,"Kwota {0} ustawiona w tym żądaniu płatności różni się od obliczonej kwoty wszystkich planów płatności: {1}. Upewnij się, że jest to poprawne przed wysłaniem dokumentu.",
-The day(s) on which you are applying for leave are holidays. You need not apply for leave.,"Dzień (s), w którym starasz się o urlop jest święta. Nie musisz ubiegać się o urlop.",
-The field From Shareholder cannot be blank,Pole Od Akcjonariusza nie może być puste,
-The field To Shareholder cannot be blank,Pole Do akcjonariusza nie może być puste,
-The fields From Shareholder and To Shareholder cannot be blank,Pola Od Akcjonariusza i Do Akcjonariusza nie mogą być puste,
-The folio numbers are not matching,Numery folio nie pasują do siebie,
-The holiday on {0} is not between From Date and To Date,Święto w dniu {0} nie jest pomiędzy Od Data i do tej pory,
-The name of the institute for which you are setting up this system.,"Nazwa instytutu, dla którego jest utworzenie tego systemu.",
-The name of your company for which you are setting up this system.,Nazwa firmy / organizacji dla której uruchamiasz niniejszy system.,
-The number of shares and the share numbers are inconsistent,Liczba akcji i liczby akcji są niespójne,
-The payment gateway account in plan {0} is different from the payment gateway account in this payment request,Rachunek bramy płatniczej w planie {0} różni się od konta bramy płatności w tym żądaniu płatności,
-The selected BOMs are not for the same item,Wybrane LM nie są na tej samej pozycji,
-The selected item cannot have Batch,Wybrany element nie może mieć Batch,
-The seller and the buyer cannot be the same,Sprzedawca i kupujący nie mogą być tacy sami,
-The shareholder does not belong to this company,Akcjonariusz nie należy do tej spółki,
-The shares already exist,Akcje już istnieją,
-The shares don't exist with the {0},Akcje nie istnieją z {0},
-"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Zadanie zostało zakolejkowane jako zadanie w tle. W przypadku jakichkolwiek problemów z przetwarzaniem w tle, system doda komentarz dotyczący błędu w tym uzgadnianiu i powróci do etapu wersji roboczej",
-"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Następnie wycena Zasady są filtrowane na podstawie Klienta, grupy klientów, Terytorium, dostawcy, dostawca, typu kampanii, Partner Sales itp",
-"There are inconsistencies between the rate, no of shares and the amount calculated","Występują niespójności między stopą, liczbą akcji i obliczoną kwotą",
-There are more holidays than working days this month.,Jest więcej świąt niż dni pracujących,
-There can be multiple tiered collection factor based on the total spent. But the conversion factor for redemption will always be same for all the tier.,Może istnieć wiele warstwowych współczynników zbierania w oparciu o całkowitą ilość wydanych pieniędzy. Jednak współczynnik konwersji dla umorzenia będzie zawsze taki sam dla wszystkich poziomów.,
-There can only be 1 Account per Company in {0} {1},Nie może być tylko jedno konto na Spółkę w {0} {1},
-"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Może być tylko jedna Zasada dostawy z wartością 0 lub pustą wartością w polu ""Wartość""",
-There is no leave period in between {0} and {1},Nie ma okresu próbnego między {0} a {1},
-There is not enough leave balance for Leave Type {0},,
-There is nothing to edit.,Nie ma nic do edycji,
-There isn't any item variant for the selected item,Nie ma żadnego wariantu przedmiotu dla wybranego przedmiotu,
-"There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.","Wygląda na to, że problem dotyczy konfiguracji serwera GoCardless. Nie martw się, w przypadku niepowodzenia kwota zostanie zwrócona na Twoje konto.",
-There were errors creating Course Schedule,Podczas tworzenia harmonogramu kursów wystąpiły błędy,
-There were errors.,Wystąpiły błędy,
-This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"Pozycja ta jest szablon i nie mogą być wykorzystywane w transakcjach. Atrybuty pozycji zostaną skopiowane nad do wariantów chyba ""Nie Kopiuj"" jest ustawiony",
-This Item is a Variant of {0} (Template).,Ta pozycja jest wariantem {0} (szablon).,
-This Month's Summary,Podsumowanie tego miesiąca,
-This Week's Summary,Podsumowanie W tym tygodniu,
-This action will stop future billing. Are you sure you want to cancel this subscription?,Ta czynność zatrzyma przyszłe płatności. Czy na pewno chcesz anulować subskrypcję?,
-This covers all scorecards tied to this Setup,Obejmuje to wszystkie karty wyników powiązane z niniejszą kartą,
-This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Niniejszy dokument ma na granicy przez {0} {1} dla pozycji {4}. Robisz kolejny {3} przeciwko samo {2}?,
-This is a root account and cannot be edited.,To jest konto root i nie może być edytowane.,
-This is a root customer group and cannot be edited.,To jest grupa klientów root i nie mogą być edytowane.,
-This is a root department and cannot be edited.,To jest dział główny i nie można go edytować.,
-This is a root healthcare service unit and cannot be edited.,To jest podstawowa jednostka opieki zdrowotnej i nie można jej edytować.,
-This is a root item group and cannot be edited.,To jest grupa przedmiotów root i nie mogą być edytowane.,
-This is a root sales person and cannot be edited.,To jest sprzedawca root i nie może być edytowany.,
-This is a root supplier group and cannot be edited.,To jest główna grupa dostawców i nie można jej edytować.,
-This is a root territory and cannot be edited.,To jest obszar root i nie może być edytowany.,
-This is an example website auto-generated from ERPNext,Ta przykładowa strona została automatycznie wygenerowana przez ERPNext,
-This is based on logs against this Vehicle. See timeline below for details,Opiera się to na dzienniki przeciwko tego pojazdu. Zobacz harmonogram poniżej w szczegółach,
-This is based on stock movement. See {0} for details,Jest to oparte na ruchu zapasów. Zobacz {0} o szczegóły,
-This is based on the Time Sheets created against this project,Jest to oparte na kartach czasu pracy stworzonych wobec tego projektu,
-This is based on the attendance of this Employee,Jest to oparte na obecności pracownika,
-This is based on the attendance of this Student,Jest to oparte na obecności tego Studenta,
-This is based on transactions against this Customer. See timeline below for details,"Wykres oparty na operacjach związanych z klientem. Sprawdź poniżej oś czasu, aby uzyskać więcej szczegółów.",
-This is based on transactions against this Healthcare Practitioner.,Jest to oparte na transakcjach przeciwko temu pracownikowi opieki zdrowotnej.,
-This is based on transactions against this Patient. See timeline below for details,"Opiera się to na transakcjach przeciwko temu pacjentowi. Zobacz poniżej linię czasu, aby uzyskać szczegółowe informacje",
-This is based on transactions against this Sales Person. See timeline below for details,"Jest to oparte na transakcjach z tą osobą handlową. Zobacz oś czasu poniżej, aby uzyskać szczegółowe informacje",
-This is based on transactions against this Supplier. See timeline below for details,"Wykres oparty na operacjach związanych z dostawcą. Sprawdź poniżej oś czasu, aby uzyskać więcej szczegółów.",
-This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Spowoduje to wysłanie Salary Slips i utworzenie wpisu księgowego. Czy chcesz kontynuować?,
-This {0} conflicts with {1} for {2} {3},Ten {0} konflikty z {1} do {2} {3},
-Time Sheet for manufacturing.,Arkusz Czas produkcji.,
-Time Tracking,time Tracking,
-"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Przesunięcie przedziału czasowego, przedział od {0} do {1} pokrywa się z istniejącym bokiem {2} do {3}",
-Time slots added,Dodano gniazda czasowe,
-Time(in mins),Czas (w minutach),
-Timer,Regulator czasowy,
-Timer exceeded the given hours.,Minutnik przekroczył podane godziny.,
-Timesheet,Lista obecności,
-Timesheet for tasks.,Grafiku zadań.,
-Timesheet {0} is already completed or cancelled,Grafiku {0} jest już zakończone lub anulowane,
-Timesheets,Ewidencja czasu pracy,
-"Timesheets help keep track of time, cost and billing for activites done by your team","Ewidencja czasu pomaga śledzić czasu, kosztów i rozliczeń dla aktywnosci przeprowadzonych przez zespół",
-Titles for print templates e.g. Proforma Invoice.,Tytuł szablonu wydruku np.: Faktura Proforma,
-To,Do,
-To Address 1,Aby Adres 1,
-To Address 2,Do adresu 2,
-To Bill,Wystaw rachunek,
-To Date,Do daty,
-To Date cannot be before From Date,"""Do daty"" nie może być terminem przed ""od daty""",
-To Date cannot be less than From Date,Data nie może być mniejsza niż Od daty,
-To Date must be greater than From Date,To Date musi być większe niż From Date,
-To Date should be within the Fiscal Year. Assuming To Date = {0},Aby Data powinna być w tym roku podatkowym. Zakładając To Date = {0},
-To Datetime,Aby DateTime,
-To Deliver,Dostarczyć,
-To Deliver and Bill,Do dostarczenia i Bill,
-To Fiscal Year,Do roku podatkowego,
-To GSTIN,Do GSTIN,
-To Party Name,Nazwa drużyny,
-To Pin Code,Aby przypiąć kod,
-To Place,Do miejsca,
-To Receive,Otrzymać,
-To Receive and Bill,Do odbierania i Bill,
-To State,Określić,
-To Warehouse,Do magazynu,
-To create a Payment Request reference document is required,"Aby utworzyć dokument referencyjny żądania zapłaty, wymagane jest",
-To date can not be equal or less than from date,Do tej pory nie może być równa lub mniejsza niż od daty,
-To date can not be less than from date,Do tej pory nie może być mniejsza niż od daty,
-To date can not greater than employee's relieving date,Do tej pory nie może przekroczyć daty zwolnienia pracownika,
-"To filter based on Party, select Party Type first","Aby filtrować na podstawie partii, wybierz Party Wpisz pierwsze",
-"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Aby uzyskać najlepsze z ERPNext, zalecamy, aby poświęcić trochę czasu i oglądać te filmy pomoc.",
-"To include tax in row {0} in Item rate, taxes in rows {1} must also be included",,
-To make Customer based incentive schemes.,Aby tworzyć systemy motywacyjne oparte na Kliencie.,
-"To merge, following properties must be same for both items","Aby scalić, poniższe właściwości muszą być takie same dla obu przedmiotów",
-"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Cennik nie stosuje regułę w danej transakcji, wszystkie obowiązujące przepisy dotyczące cen powinny być wyłączone.",
-"To set this Fiscal Year as Default, click on 'Set as Default'","Aby ustawić ten rok finansowy jako domyślny, kliknij przycisk ""Ustaw jako domyślne""",
-To view logs of Loyalty Points assigned to a Customer.,Aby wyświetlić logi punktów lojalnościowych przypisanych do klienta.,
-To {0},Do {0},
-To {0} | {1} {2},Do {0} | {1} {2},
-Toggle Filters,Przełącz filtry,
-Too many columns. Export the report and print it using a spreadsheet application.,Zbyt wiele kolumn. Wyeksportować raport i wydrukować go za pomocą arkusza kalkulacyjnego.,
-Tools,Narzędzia,
-Total (Credit),Razem (Credit),
-Total (Without Tax),Razem (bez podatku),
-Total Absent,Razem Nieobecny,
-Total Achieved,Razem Osiągnięte,
-Total Actual,Razem Rzeczywisty,
-Total Allocated Leaves,Całkowicie Przydzielone Nieobecności,
-Total Amount,Wartość całkowita,
-Total Amount Credited,Całkowita kwota kredytu,
-Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Wszystkich obowiązujących opłat w ZAKUPU Elementy tabeli muszą być takie same jak Wszystkich podatkach i opłatach,
-Total Budget,Cały budżet,
-Total Collected: {0},Łącznie zbierane: {0},
-Total Commission,Całkowita kwota prowizji,
-Total Contribution Amount: {0},Łączna kwota dotacji: {0},
-Total Credit/ Debit Amount should be same as linked Journal Entry,"Całkowita kwota kredytu / debetu powinna być taka sama, jak połączona pozycja księgowa",
-Total Debit must be equal to Total Credit. The difference is {0},Całkowita kwota po stronie debetowej powinna być równa całkowitej kwocie po stronie kretytowej. Różnica wynosi {0},
-Total Deduction,Całkowita kwota odliczenia,
-Total Invoiced Amount,Całkowita zafakturowana kwota,
-Total Leaves,Wszystkich Nieobecności,
-Total Order Considered,Zamówienie razem Uważany,
-Total Order Value,Łączna wartość zamówienia,
-Total Outgoing,Razem Wychodzące,
-Total Outstanding,Total Outstanding,
-Total Outstanding Amount,Łączna kwota,
-Total Outstanding: {0},Całkowity stan: {0},
-Total Paid Amount,Kwota całkowita Płatny,
-Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Całkowita kwota płatności w harmonogramie płatności musi być równa sumie całkowitej / zaokrąglonej,
-Total Payments,Płatności ogółem,
-Total Present,Razem Present,
-Total Qty,Razem szt,
-Total Quantity,Całkowita ilość,
-Total Revenue,Całkowita wartość dochodu,
-Total Student,Total Student,
-Total Target,Łączna docelowa,
-Total Tax,Razem podatkowa,
-Total Taxable Amount,Całkowita kwota podlegająca opodatkowaniu,
-Total Taxable Value,Całkowita wartość podlegająca opodatkowaniu,
-Total Unpaid: {0},Razem Niepłatny: {0},
-Total Variance,Całkowitej wariancji,
-Total Weightage of all Assessment Criteria must be 100%,Razem weightage wszystkich kryteriów oceny muszą być w 100%,
-Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Suma zaliczki ({0}) przed zamówieniem {1} nie może być większa od ogólnej sumy ({2}),
-Total advance amount cannot be greater than total claimed amount,Całkowita kwota zaliczki nie może być większa niż całkowita kwota roszczenia,
-Total advance amount cannot be greater than total sanctioned amount,Całkowita kwota zaliczki nie może być większa niż całkowita kwota sankcjonowana,
-Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,Całkowita liczba przydzielonych urlopów to więcej dni niż maksymalny przydział {0} typu urlopu dla pracownika {1} w danym okresie,
-Total allocated leaves are more than days in the period,Liczba przyznanych zwolnień od pracy jest większa niż dni w okresie,
-Total allocated percentage for sales team should be 100,Łącznie przydzielony procent sprzedaży dla zespołu powinien wynosić 100,
-Total cannot be zero,Razem nie może być wartością zero,
-Total contribution percentage should be equal to 100,Całkowity procent wkładu powinien być równy 100,
-Total flexible benefit component amount {0} should not be less than max benefits {1},Całkowita kwota elastycznego składnika świadczeń {0} nie powinna być mniejsza niż maksymalna korzyść {1},
-Total hours: {0},Całkowita liczba godzin: {0},
-Total leaves allocated is mandatory for Leave Type {0},Całkowita liczba przydzielonych Nieobecności jest obowiązkowa dla Typu Urlopu {0},
-Total working hours should not be greater than max working hours {0},Całkowita liczba godzin pracy nie powinna być większa niż max godzinach pracy {0},
-Total {0} ({1}),Razem {0} ({1}),
-"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Razem {0} dla wszystkich elementów wynosi zero, może trzeba zmienić „Dystrybucja opłat na podstawie”",
-Total(Amt),Razem (Amt),
-Total(Qty),Razem (szt),
-Traceability,Śledzenie,
-Traceback,Traceback,
-Track Leads by Lead Source.,Śledzenie potencjalnych klientów przez źródło potencjalnych klientów.,
-Training,Trening,
-Training Event,Training Event,
-Training Events,Wydarzenia szkoleniowe,
-Training Feedback,Szkolenie Zgłoszenie,
-Training Result,Wynik treningowe,
-Transaction,Transakcja,
-Transaction Date,Data transakcji,
-Transaction Type,typ transakcji,
-Transaction currency must be same as Payment Gateway currency,"Waluta transakcji musi być taka sama, jak waluta wybranej płatności",
-Transaction not allowed against stopped Work Order {0},Transakcja nie jest dozwolona w przypadku zatrzymanego zlecenia pracy {0},
-Transaction reference no {0} dated {1},Transakcja ma odniesienia {0} z {1},
-Transactions,Transakcje,
-Transactions can only be deleted by the creator of the Company,Transakcje mogą być usunięte tylko przez twórcę Spółki,
-Transfer,Transfer,
-Transfer Material,Transfer materiału,
-Transfer Type,Rodzaj transferu,
-Transfer an asset from one warehouse to another,Przeniesienie aktywów z jednego magazynu do drugiego,
-Transfered,Przeniesione,
-Transferred Quantity,Przeniesiona ilość,
-Transport Receipt Date,Transport Data odbioru,
-Transport Receipt No,Nr odbioru transportu,
-Transportation,Transport,
-Transporter ID,Identyfikator transportera,
-Transporter Name,Nazwa przewoźnika,
-Travel,Podróż,
-Travel Expenses,Wydatki na podróże,
-Tree Type,Typ drzewa,
-Tree of Bill of Materials,Drzewo Zestawienia materiałów,
-Tree of Item Groups.,Drzewo grupy produktów,
-Tree of Procedures,Drzewo procedur,
-Tree of Quality Procedures.,Drzewo procedur jakości.,
-Tree of financial Cost Centers.,Drzewo MPK finansowych.,
-Tree of financial accounts.,Drzewo kont finansowych.,
-Treshold {0}% appears more than once,Próg {0}% występuje więcej niż jeden raz,
-Trial Period End Date Cannot be before Trial Period Start Date,Termin zakończenia okresu próbnego Nie może być przed datą rozpoczęcia okresu próbnego,
-Trialling,Trialling,
-Type of Business,Rodzaj biznesu,
-Types of activities for Time Logs,Rodzaje działalności za czas Logi,
-UOM,Jednostka miary,
-UOM Conversion factor is required in row {0},Współczynnik konwersji jednostki miary jest wymagany w rzędzie {0},
-UOM coversion factor required for UOM: {0} in Item: {1},Współczynnik konwersji jednostki miary jest wymagany dla jednostki miary: {0} w Przedmiocie: {1},
-URL,URL,
-Unable to find DocType {0},Nie można znaleźć DocType {0},
-Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Nie można znaleźć kursu wymiany dla {0} do {1} dla daty klucza {2}. Proszę utworzyć ręcznie rekord wymiany walut,
-Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,"Nie można znaleźć wyników, począwszy od {0}. Musisz mieć stały wynik od 0 do 100",
-Unable to find variable: ,Nie można znaleźć zmiennej:,
-Unblock Invoice,Odblokuj fakturę,
-Uncheck all,Odznacz wszystkie,
-Unclosed Fiscal Years Profit / Loss (Credit),Unclosed fiskalna Lata Zysk / Strata (Credit),
-Unit,szt.,
-Unit of Measure,Jednostka miary,
-Unit of Measure {0} has been entered more than once in Conversion Factor Table,Jednostka miary {0} została wprowadzona więcej niż raz w Tabelce Współczynnika Konwersji,
-Unknown,Nieznany,
-Unpaid,Niezapłacone,
-Unsecured Loans,Pożyczki bez pokrycia,
-Unsubscribe from this Email Digest,Wypisać się z tej Email Digest,
-Unsubscribed,Nie zarejestrowany,
-Until,Do,
-Unverified Webhook Data,Niezweryfikowane dane z Webhook,
-Update Account Name / Number,Zaktualizuj nazwę / numer konta,
-Update Account Number / Name,Zaktualizuj numer / nazwę konta,
-Update Cost,Zaktualizuj koszt,
-Update Items,Aktualizuj elementy,
-Update Print Format,Aktualizacja Format wydruku,
-Update Response,Zaktualizuj odpowiedź,
-Update bank payment dates with journals.,Aktualizacja terminów płatności banowych,
-Update in progress. It might take a while.,Aktualizacja w toku. To może trochę potrwać.,
-Update rate as per last purchase,Zaktualizuj stawkę za ostatni zakup,
-Update stock must be enable for the purchase invoice {0},Aktualizuj zapasy musi być włączone dla faktury zakupu {0},
-Updating Variants...,Aktualizowanie wariantów ...,
-Upload your letter head and logo. (you can edit them later).,Prześlij nagłówek firmowy i logo. (Można je edytować później).,
-Upper Income,Wzrost Wpływów,
-Use Sandbox,Korzystanie Sandbox,
-Used Leaves,Wykorzystane Nieobecności,
-User,Użytkownik,
-User ID,ID Użytkownika,
-User ID not set for Employee {0},ID Użytkownika nie ustawiony dla Pracownika {0},
-User Remark,Nota Użytkownika,
-User has not applied rule on the invoice {0},Użytkownik nie zastosował reguły na fakturze {0},
-User {0} already exists,Użytkownik {0} już istnieje,
-User {0} created,Utworzono użytkownika {0},
-User {0} does not exist,Użytkownik {0} nie istnieje,
-User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Użytkownik {0} nie ma żadnego domyślnego profilu POS. Sprawdź domyślne w wierszu {1} dla tego użytkownika.,
-User {0} is already assigned to Employee {1},Użytkownik {0} jest już przyporządkowany do Pracownika {1},
-User {0} is already assigned to Healthcare Practitioner {1},Użytkownik {0} jest już przypisany do pracownika służby zdrowia {1},
-Users,Użytkownicy,
-Utility Expenses,Wydatki na usługi komunalne,
-Valid From Date must be lesser than Valid Upto Date.,Ważny od daty musi być mniejszy niż ważna data w górę.,
-Valid Till,Obowiązuje do dnia,
-Valid from and valid upto fields are mandatory for the cumulative,Obowiązujące od i prawidłowe pola upto są obowiązkowe dla skumulowanego,
-Valid from date must be less than valid upto date,Ważny od daty musi być krótszy niż data ważności,
-Valid till date cannot be before transaction date,Data ważności nie może być poprzedzona datą transakcji,
-Validity,Ważność,
-Validity period of this quotation has ended.,Okres ważności tej oferty zakończył się.,
-Valuation Rate,Wskaźnik wyceny,
-Valuation Rate is mandatory if Opening Stock entered,"Wycena Cena jest obowiązkowe, jeżeli wprowadzone Otwarcie Zdjęcie",
-Valuation type charges can not marked as Inclusive,Opłaty typu Wycena nie oznaczone jako Inclusive,
-Value Or Qty,Wartość albo Ilość,
-Value Proposition,Propozycja wartości,
-Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Wartość atrybutu {0} musi mieścić się w przedziale {1} z {2} w przyrostach {3} {4} Przedmiot,
-Value missing,Wartość brakująca,
-Value must be between {0} and {1},Wartość musi zawierać się między {0} a {1},
-"Values of exempt, nil rated and non-GST inward supplies","Wartości zwolnionych, zerowych i niezawierających GST dostaw wewnętrznych",
-Variable,Zmienna,
-Variance,Zmienność,
-Variance ({}),Wariancja ({}),
-Variant,Wariant,
-Variant Attributes,Variant Atrybuty,
-Variant Based On cannot be changed,Variant Based On nie może zostać zmieniony,
-Variant Details Report,Szczegółowy raport dotyczący wariantu,
-Variant creation has been queued.,Tworzenie wariantu zostało umieszczone w kolejce.,
-Vehicle Expenses,Wydatki Samochodowe,
-Vehicle No,Nr pojazdu,
-Vehicle Type,Typ pojazdu,
-Vehicle/Bus Number,Numer pojazdu / autobusu,
-Venture Capital,Kapitał wysokiego ryzyka,
-View Chart of Accounts,Zobacz plan kont,
-View Fees Records,Zobacz rekord opłat,
-View Form,Wyświetl formularz,
-View Lab Tests,Wyświetl testy laboratoryjne,
-View Leads,Zobacz Tropy,
-View Ledger,Podgląd księgi,
-View Now,Zobacz teraz,
-View a list of all the help videos,Zobacz listę wszystkich filmów pomocy,
-View in Cart,Zobacz Koszyk,
-Visit report for maintenance call.,Raport wizyty dla wezwania konserwacji.,
-Visit the forums,Odwiedź fora,
-Vital Signs,Oznaki życia,
-Volunteer,Wolontariusz,
-Volunteer Type information.,Informacje o typie wolontariusza.,
-Volunteer information.,Informacje o wolontariuszu.,
-Voucher #,Bon #,
-Voucher No,Nr Podstawy księgowania,
-Voucher Type,Typ Podstawy,
-WIP Warehouse,WIP Magazyn,
-Walk In,Wejście,
-Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Magazyn nie może być skasowany tak długo jak długo istnieją zapisy w księdze stanu dla tego magazynu.,
-Warehouse cannot be changed for Serial No.,Magazyn nie może być zmieniony dla Nr Seryjnego,
-Warehouse is mandatory,Magazyn jest obowiązkowe,
-Warehouse is mandatory for stock Item {0} in row {1},Magazyn jest obowiązkowy dla Przedmiotu {0} w rzędzie {1},
-Warehouse not found in the system,Magazyn nie został znaleziony w systemie,
-"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}","Wymagany magazyn w Wiersz nr {0}, ustaw domyślny magazyn dla pozycji {1} dla firmy {2}",
-Warehouse required for stock Item {0},Magazyn wymagany dla przedmiotu {0},
-Warehouse {0} can not be deleted as quantity exists for Item {1},Magazyn {0} nie może zostać usunięty ponieważ istnieje wartość dla przedmiotu {1},
-Warehouse {0} does not belong to company {1},Magazyn {0} nie należy do firmy {1},
-Warehouse {0} does not exist,Magazyn {0} nie istnieje,
-"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Magazyn {0} nie jest powiązany z jakimikolwiek kontem, wspomnij o tym w raporcie magazynu lub ustaw domyślnego konta zapasowego w firmie {1}.",
-Warehouses with child nodes cannot be converted to ledger,Magazyny z węzłów potomnych nie mogą być zamieniane na Ledger,
-Warehouses with existing transaction can not be converted to group.,Magazyny z istniejącymi transakcji nie mogą być zamieniane na grupy.,
-Warehouses with existing transaction can not be converted to ledger.,Magazyny z istniejącymi transakcji nie mogą być konwertowane do księgi głównej.,
-Warning,Ostrzeżenie,
-Warning: Another {0} # {1} exists against stock entry {2},Ostrzeżenie: Inny {0} # {1} istnieje we wpisie asortymentu {2},
-Warning: Invalid SSL certificate on attachment {0},Ostrzeżenie: Nieprawidłowy certyfikat SSL w załączniku {0},
-Warning: Invalid attachment {0},Warning: Invalid Załącznik {0},
-Warning: Leave application contains following block dates,Ostrzeżenie: Aplikacja o urlop zawiera następujące zablokowane daty,
-Warning: Material Requested Qty is less than Minimum Order Qty,Ostrzeżenie: Ilość Zapotrzebowanego Materiału jest mniejsza niż minimalna ilość na zamówieniu,
-Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Ostrzeżenie: Zamówienie sprzedaży {0} już istnieje wobec Klienta Zamówienia {1},
-Warning: System will not check overbilling since amount for Item {0} in {1} is zero,,
-Warranty,Gwarancja,
-Warranty Claim,Roszczenie gwarancyjne,
-Warranty Claim against Serial No.,Roszczenie gwarancyjne z numerem seryjnym,
-Website,Strona WWW,
-Website Image should be a public file or website URL,Strona Obraz powinien być plik publiczny lub adres witryny,
-Website Image {0} attached to Item {1} cannot be found,Strona Obraz {0} dołączone do pozycji {1} nie można znaleźć,
-Website Listing,Listing Witryny,
-Website Manager,Manager strony WWW,
-Website Settings,Ustawienia witryny,
-Wednesday,Środa,
-Week,Tydzień,
-Weekdays,Dni robocze,
-Weekly,Tygodniowo,
-"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Waga jest określona, \n Ustaw także ""Wagę jednostkową""",
-Welcome email sent,E-mail z powitaniem został wysłany,
-Welcome to ERPNext,Zapraszamy do ERPNext,
-What do you need help with?,Z czym potrzebujesz pomocy?,
-What does it do?,Czym się zajmuje?,
-Where manufacturing operations are carried.,"W przypadku, gdy czynności wytwórcze są prowadzone.",
-White,Biały,
-Wire Transfer,Przelew,
-WooCommerce Products,Produkty WooCommerce,
-Work In Progress,Produkty w toku,
-Work Order,Porządek pracy,
-Work Order already created for all items with BOM,Zamówienie pracy zostało już utworzone dla wszystkich produktów z zestawieniem komponentów,
-Work Order cannot be raised against a Item Template,Zlecenie pracy nie może zostać podniesione na podstawie szablonu przedmiotu,
-Work Order has been {0},Zamówienie pracy zostało {0},
-Work Order not created,Zamówienie pracy nie zostało utworzone,
-Work Order {0} must be cancelled before cancelling this Sales Order,Zamówienie pracy {0} musi zostać anulowane przed anulowaniem tego zamówienia sprzedaży,
-Work Order {0} must be submitted,Zamówienie pracy {0} musi zostać przesłane,
-Work Orders Created: {0},Utworzono zlecenia pracy: {0},
-Work Summary for {0},Podsumowanie pracy dla {0},
-Work-in-Progress Warehouse is required before Submit,Magazyn z produkcją w toku jest wymagany przed wysłaniem,
-Workflow,Przepływ pracy (Workflow),
-Working,Pracuje,
-Working Hours,Godziny pracy,
-Workstation,Stacja robocza,
-Workstation is closed on the following dates as per Holiday List: {0},Stacja robocza jest zamknięta w następujących terminach wg listy wakacje: {0},
-Wrapping up,Zawijanie,
-Wrong Password,Niepoprawne hasło,
-Year start date or end date is overlapping with {0}. To avoid please set company,data rozpoczęcia roku lub data końca pokrywa się z {0}. Aby uniknąć należy ustawić firmę,
-You are not authorized to add or update entries before {0},Nie masz uprawnień aby zmieniać lub dodawać elementy przed {0},
-You are not authorized to approve leaves on Block Dates,Nie masz uprawnień do zatwierdzania tych urlopów,
-You are not authorized to set Frozen value,Nie masz uprawnień do ustawienia zamrożenej wartości,
-You are not present all day(s) between compensatory leave request days,Nie jesteś obecny przez cały dzień (dni) między dniami prośby o urlop wyrównawczy,
-You can not change rate if BOM mentioned agianst any item,Nie możesz zmienić danych jeśli BOM jest przeciw jakiejkolwiek rzeczy,
-You can not enter current voucher in 'Against Journal Entry' column,You can not enter current voucher in 'Against Journal Entry' column,
-You can only have Plans with the same billing cycle in a Subscription,Możesz mieć tylko Plany z tym samym cyklem rozliczeniowym w Subskrypcji,
-You can only redeem max {0} points in this order.,Możesz maksymalnie wykorzystać maksymalnie {0} punktów w tej kolejności.,
-You can only renew if your membership expires within 30 days,Przedłużenie członkostwa można odnowić w ciągu 30 dni,
-You can only select a maximum of one option from the list of check boxes.,Możesz wybrać maksymalnie jedną opcję z listy pól wyboru.,
-You can only submit Leave Encashment for a valid encashment amount,Możesz przesłać tylko opcję Leave Encashment dla prawidłowej kwoty depozytu,
-You can't redeem Loyalty Points having more value than the Grand Total.,Nie możesz wymienić punktów lojalnościowych o większej wartości niż suma ogólna.,
-You cannot credit and debit same account at the same time,Nie można wykonywać zapisów po stronie debetowej oraz kredytowej tego samego konta w jednym czasie,
-You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Nie można usunąć Fiscal Year {0}. Rok fiskalny {0} jest ustawiona jako domyślna w Ustawienia globalne,
-You cannot delete Project Type 'External',Nie można usunąć typu projektu &quot;zewnętrzny&quot;,
-You cannot edit root node.,Nie można edytować węzła głównego.,
-You cannot restart a Subscription that is not cancelled.,"Nie można ponownie uruchomić subskrypcji, która nie zostanie anulowana.",
-You don't have enought Loyalty Points to redeem,"Nie masz wystarczającej liczby Punktów Lojalnościowych, aby je wykorzystać",
-You have already assessed for the assessment criteria {}.,Oceniałeś już kryteria oceny {}.,
-You have already selected items from {0} {1},Już wybrane pozycje z {0} {1},
-You have been invited to collaborate on the project: {0},Zostałeś zaproszony do współpracy przy projekcie: {0},
-You have entered duplicate items. Please rectify and try again.,Wprowadziłeś duplikat istniejących rzeczy. Sprawdź i spróbuj ponownie,
-You need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,"Aby zarejestrować się w Marketplace, musisz być użytkownikiem innym niż Administrator z rolami System Manager i Item Manager.",
-You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,"Musisz być użytkownikiem z rolami System Manager i Menedżera elementów, aby dodawać użytkowników do Marketplace.",
-You need to be a user with System Manager and Item Manager roles to register on Marketplace.,"Aby zarejestrować się w Marketplace, musisz być użytkownikiem z rolami System Manager i Item Manager.",
-You need to be logged in to access this page,Musisz być zalogowany aby uzyskać dostęp do tej strony,
-You need to enable Shopping Cart,Musisz włączyć Koszyk,
-You will lose records of previously generated invoices. Are you sure you want to restart this subscription?,Utracisz zapis wcześniej wygenerowanych faktur. Czy na pewno chcesz zrestartować tę subskrypcję?,
-Your Organization,Twoja organizacja,
-Your cart is Empty,Twój koszyk jest pusty,
-Your email address...,Twój adres email...,
-Your order is out for delivery!,Twoje zamówienie jest na dostawę!,
-Your tickets,Twoje bilety,
-ZIP Code,Kod pocztowy,
-[Error],[Błąd],
-[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Postać / poz / {0}) jest niedostępne,
-`Freeze Stocks Older Than` should be smaller than %d days.,Zapasy starsze niż' powinny być starczyć na %d dni,
-based_on,oparte na,
-cannot be greater than 100,nie może być większa niż 100,
-disabled user,Wyłączony użytkownik,
-"e.g. ""Build tools for builders""","np. ""Buduj narzędzia dla budowniczych""",
-"e.g. ""Primary School"" or ""University""",np &quot;Szkoła Podstawowa&quot; lub &quot;Uniwersytet&quot;,
-"e.g. Bank, Cash, Credit Card","np. bank, gotówka, karta kredytowa",
-hidden,ukryty,
-modified,Zmodyfikowano,
-old_parent,old_parent,
-on,włączony,
-{0} '{1}' is disabled,{0} '{1}' jest wyłączony,
-{0} '{1}' not in Fiscal Year {2},{0} '{1}' nie w roku podatkowym {2},
-{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) nie może być większe niż planowana ilość ({2}) w zleceniu pracy {3},
-{0} - {1} is inactive student,{0} - {1} to nieaktywny student,
-{0} - {1} is not enrolled in the Batch {2},{0} - {1} nie jest powiązana z transakcją {2},
-{0} - {1} is not enrolled in the Course {2},{0} - {1} nie jest zapisany do kursu {2},
-{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} Budżet dla rachunku {1} w stosunku do {2} {3} wynosi {4}. Będzie przekraczać o {5},
-{0} Digest,{0} Streszczenie,
-{0} Request for {1},{0} Wniosek o {1},
-{0} Result submittted,{0} Wynik wysłano,
-{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Numery seryjne wymagane dla pozycji {1}. Podałeś {2}.,
-{0} Student Groups created.,{0} Utworzono grupy studentów.,
-{0} Students have been enrolled,{0} Studenci zostali zapisani,
-{0} against Bill {1} dated {2},{0} przed rachunkiem {1} z dnia {2},
-{0} against Purchase Order {1},{0} przed Zamówieniem Zakupu  {1},
-{0} against Sales Invoice {1},{0} na fakturę sprzedaży {1},
-{0} against Sales Order {1},{0} przed Zleceniem Sprzedaży {1},
-{0} already allocated for Employee {1} for period {2} to {3},{0} już przydzielone Pracodawcy {1} dla okresu {2} do {3},
-{0} applicable after {1} working days,{0} obowiązuje po {1} dniach roboczych,
-{0} asset cannot be transferred,{0} zasób nie może zostać przetransferowany,
-{0} can not be negative,{0} nie może być ujemna,
-{0} created,{0} utworzone,
-"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.","{0} aktualnie posiada pozycję {1} Karty wyników dostawcy, a zlecenia kupna dostawcy powinny być wydawane z ostrożnością.",
-"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.","{0} aktualnie posiada {1} tabelę wyników karty wyników, a zlecenia RFQ dla tego dostawcy powinny być wydawane z ostrożnością.",
-{0} does not belong to Company {1},{0} nie należy do firmy {1},
-{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0} nie ma harmonogramu służby zdrowia. Dodaj go do mistrza Healthcare Practitioner,
-{0} entered twice in Item Tax,{0} dwa razy wprowadzone w podatku produktu,
-{0} for {1},{0} do {1},
-{0} has been submitted successfully,{0} zostało pomyślnie przesłane,
-{0} has fee validity till {1},{0} ważność opłaty do {1},
-{0} hours,{0} godzin,
-{0} in row {1},{0} wiersze {1},
-{0} is blocked so this transaction cannot proceed,"Opcja {0} jest zablokowana, więc ta transakcja nie może być kontynuowana",
-{0} is mandatory,{0} jest obowiązkowe,
-{0} is mandatory for Item {1},{0} jest obowiązkowe dla elementu {1},
-{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,"{0} jest obowiązkowe. Możliwe, że rekord Wymiana walut nie jest utworzony dla {1} do {2}.",
-{0} is not a stock Item,{0} nie jest przechowywany na magazynie,
-{0} is not a valid Batch Number for Item {1},,
-{0} is not added in the table,{0} nie zostało dodane do tabeli,
-{0} is not in Optional Holiday List,{0} nie znajduje się na Opcjonalnej Liście Świątecznej,
-{0} is not in a valid Payroll Period,{0} nie jest w ważnym Okresie Rozliczeniowym,
-{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} jest teraz domyślnym rokiem finansowym. Odśwież swoją przeglądarkę aby zmiana weszła w życie,
-{0} is on hold till {1},{0} jest wstrzymane do {1},
-{0} item found.,Znaleziono {0} element.,
-{0} items found.,Znaleziono {0} przedmiotów.,
-{0} items in progress,{0} pozycji w przygotowaniu,
-{0} items produced,{0} pozycji wyprodukowanych,
-{0} must appear only once,{0} musi pojawić się tylko raz,
-{0} must be negative in return document,{0} musi być ujemna w dokumencie zwrotnym,
-{0} must be submitted,{0} musi zostać wysłany,
-{0} not allowed to transact with {1}. Please change the Company.,{0} nie może przeprowadzać transakcji z {1}. Zmień firmę.,
-{0} not found for item {1},{0} nie został znaleziony dla elementu {1},
-{0} parameter is invalid,Parametr {0} jest nieprawidłowy,
-{0} payment entries can not be filtered by {1},{0} wpisy płatności nie mogą być filtrowane przez {1},
-{0} should be a value between 0 and 100,{0} powinno być wartością z zakresu od 0 do 100,
-{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} jednostki [{1}] (# Kształt / szt / {1}) znajduje się w [{2}] (# Kształt / Warehouse / {2}),
-{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} jednostki {1} potrzebne w {2} na {3} {4} {5} w celu zrealizowania tej transakcji.,
-{0} units of {1} needed in {2} to complete this transaction.,"{0} jednostki {1} potrzebne w {2}, aby zakończyć tę transakcję.",
-{0} valid serial nos for Item {1},{0} prawidłowe numery seryjne dla Pozycji {1},
-{0} variants created.,Utworzono wariantów {0}.,
-{0} {1} created,{0} {1} utworzone,
-{0} {1} does not exist,{0} {1} nie istnieje,
-{0} {1} has been modified. Please refresh.,{0} {1} został zmodyfikowany. Proszę odświeżyć.,
-{0} {1} has not been submitted so the action cannot be completed,"{0} {1} nie został złożony, więc działanie nie może zostać zakończone",
-"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} jest powiązane z {2}, ale rachunek strony jest {3}",
-{0} {1} is cancelled or closed,{0} {1} zostanie anulowane lub zamknięte,
-{0} {1} is cancelled or stopped,{0} {1} jest anulowane lub wstrzymane,
-{0} {1} is cancelled so the action cannot be completed,"{0} {1} jest anulowany, więc działanie nie może zostać zakończone",
-{0} {1} is closed,{0} {1} jest zamknięty,
-{0} {1} is disabled,{0} {1} jest wyłączony,
-{0} {1} is frozen,{0} {1} jest zamrożone,
-{0} {1} is fully billed,{0} {1} jest w pełni rozliczone,
-{0} {1} is not active,{0} {1} jest nieaktywny,
-{0} {1} is not associated with {2} {3},{0} {1} nie jest powiązane z {2} {3},
-{0} {1} is not present in the parent company,{0} {1} nie występuje w firmie macierzystej,
-{0} {1} is not submitted,{0} {1} nie zostało dodane,
-{0} {1} is {2},{0} {1} to {2},
-{0} {1} must be submitted,{0} {1} musi zostać wysłane,
-{0} {1} not in any active Fiscal Year.,{0} {1} nie w każdej aktywnej roku obrotowego.,
-{0} {1} status is {2},{0} {1} jest ustawiony w stanie {2},
-{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,"{0} {1}: konto ""zysków i strat"" {2} jest niedozwolone w otwierającym wejściu",
-{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Rachunek {2} nie należy do firmy {3},
-{0} {1}: Account {2} is inactive,{0} {1}: Rachunek {2} jest nieaktywny,
-{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Wejście księgowe dla {2} mogą być dokonywane wyłącznie w walucie: {3},
-{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: MPK jest obowiązkowe dla pozycji {2},
-{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,"{0} {1}: Centrum kosztów jest wymagane dla rachunku ""Zyski i straty"" {2}. Proszę ustawić domyślne centrum kosztów dla firmy.",
-{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Centrum kosztów {2} nie należy do firmy {3},
-{0} {1}: Customer is required against Receivable account {2},{0} {1}: Klient zobowiązany jest przed należność {2},
-{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Debet lub wielkość kredytu jest wymagana dla {2},
-{0} {1}: Supplier is required against Payable account {2},{0} {1}: Dostawca jest wymagany w odniesieniu do konta z możliwością opłacenia {2},
-{0}% Billed,{0}% rozliczono,
-{0}% Delivered,{0}% Dostarczono,
-"{0}: Employee email not found, hence email not sent","{0}: Email pracownika nie został znaleziony, dlatego wiadomość nie będzie wysłana",
-{0}: From {0} of type {1},{0}: Od {0} typu {1},
-{0}: From {1},{0}: {1} od,
-{0}: {1} does not exists,{0}: {1} nie istnieje,
-{0}: {1} not found in Invoice Details table,{0}: {1} Nie znaleziono tabeli w Szczegóły faktury,
-{} of {},{} z {},
-Assigned To,Przypisano do,
-Chat,Czat,
-Completed By,Ukończony przez,
-Conditions,Warunki,
-County,Powiat,
-Day of Week,Dzień tygodnia,
-"Dear System Manager,",Szanowny Dyrektorze ds. Systemu,
-Default Value,Domyślna wartość,
-Email Group,Grupa email,
-Email Settings,Ustawienia wiadomości e-mail,
-Email not sent to {0} (unsubscribed / disabled),E-mail nie wysłany do {0} (wypisany / wyłączony),
-Error Message,Komunikat o błędzie,
-Fieldtype,Typ pola,
-Help Articles,Artykuły pomocy,
-ID,ID,
-Images,Obrazy,
-Import,Import,
-Language,Język,
-Likes,Lubi,
-Merge with existing,Połączy się z istniejącą,
-Office,Biuro,
-Orientation,Orientacja,
-Parent,Nadrzędny,
-Passive,Nieaktywny,
-Payment Failed,Płatność nie powiodła się,
-Percent,Procent,
-Permanent,Stały,
-Personal,Osobiste,
-Plant,Zakład,
-Post,Stanowisko,
-Postal,Pocztowy,
-Postal Code,Kod pocztowy,
-Previous,Wstecz,
-Provider,Dostawca,
-Read Only,Tylko do odczytu,
-Recipient,Adresat,
-Reviews,Recenzje,
-Sender,Nadawca,
-Shop,Sklep,
-Subsidiary,Pomocniczy,
-There is some problem with the file url: {0},Jest jakiś problem z adresem URL pliku: {0},
-There were errors while sending email. Please try again.,Wystąpiły błędy podczas wysyłki e-mail. Proszę spróbuj ponownie.,
-Values Changed,Zmienione wartości,
-or,albo,
-Ageing Range 4,Zakres starzenia się 4,
-Allocated amount cannot be greater than unadjusted amount,Kwota przydzielona nie może być większa niż kwota nieskorygowana,
-Allocated amount cannot be negative,Przydzielona kwota nie może być ujemna,
-"Difference Account must be a Asset/Liability type account, since this Stock Entry is an Opening Entry","Konto różnicowe musi być kontem typu Asset / Liability, ponieważ ten wpis na giełdę jest wpisem otwierającym",
-Error in some rows,Błąd w niektórych wierszach,
-Import Successful,Import zakończony sukcesem,
-Please save first,Zapisz najpierw,
-Price not found for item {0} in price list {1},Nie znaleziono ceny dla przedmiotu {0} w cenniku {1},
-Warehouse Type,Typ magazynu,
-'Date' is required,„Data” jest wymagana,
-Benefit,Zasiłek,
-Budgets,Budżety,
-Bundle Qty,Ilość paczek,
-Company GSTIN,Firma GSTIN,
-Company field is required,Wymagane jest pole firmowe,
-Creating Dimensions...,Tworzenie wymiarów ...,
-Duplicate entry against the item code {0} and manufacturer {1},Zduplikowany wpis względem kodu produktu {0} i producenta {1},
-Invalid GSTIN! The input you've entered doesn't match the GSTIN format for UIN Holders or Non-Resident OIDAR Service Providers,Nieprawidłowy GSTIN! Wprowadzone dane nie odpowiadają formatowi GSTIN dla posiadaczy UIN lub nierezydentów dostawców usług OIDAR,
-Invoice Grand Total,Faktura Grand Total,
-Last carbon check date cannot be a future date,Data ostatniej kontroli emisji nie może być datą przyszłą,
-Make Stock Entry,Zrób wejście na giełdę,
-Quality Feedback,Opinie dotyczące jakości,
-Quality Feedback Template,Szablon opinii o jakości,
-Rules for applying different promotional schemes.,Zasady stosowania różnych programów promocyjnych.,
-Shift,Przesunięcie,
-Show {0},Pokaż {0},
-"Special Characters except '-', '#', '.', '/', '{{' and '}}' not allowed in naming series {0}","Znaki specjalne z wyjątkiem &quot;-&quot;, &quot;#&quot;, &quot;।&quot;, &quot;/&quot;, &quot;{{&quot; I &quot;}}&quot; niedozwolone w serii nazw {0}",
-Target Details,Szczegóły celu,
-{0} already has a Parent Procedure {1}.,{0} ma już procedurę nadrzędną {1}.,
-API,API,
-Annual,Roczny,
-Approved,Zatwierdzono,
-Change,Reszta,
-Contact Email,E-mail kontaktu,
-Export Type,Typ eksportu,
-From Date,Od daty,
-Group By,Grupuj według,
-Importing {0} of {1},Importowanie {0} z {1},
-Invalid URL,nieprawidłowy URL,
-Landscape,Krajobraz,
-Last Sync On,Ostatnia synchronizacja,
-Naming Series,Seria nazw,
-No data to export,Brak danych do eksportu,
-Portrait,Portret,
-Print Heading,Nagłówek do druku,
-Scheduler Inactive,Harmonogram nieaktywny,
-Scheduler is inactive. Cannot import data.,Program planujący jest nieaktywny. Nie można zaimportować danych.,
-Show Document,Pokaż dokument,
-Show Traceback,Pokaż śledzenie,
-Video,Wideo,
-Webhook Secret,Secret Webhook,
-% Of Grand Total,% Ogólnej sumy,
-'employee_field_value' and 'timestamp' are required.,Wymagane są „wartość_pola pracownika” i „znacznik czasu”.,
-<b>Company</b> is a mandatory filter.,<b>Firma</b> jest obowiązkowym filtrem.,
-<b>From Date</b> is a mandatory filter.,<b>Od daty</b> jest obowiązkowym filtrem.,
-<b>From Time</b> cannot be later than <b>To Time</b> for {0},<b>Od godziny</b> nie może być późniejsza niż <b>do godziny</b> dla {0},
-<b>To Date</b> is a mandatory filter.,<b>To Data</b> jest obowiązkowym filtrem.,
-A new appointment has been created for you with {0},Utworzono dla ciebie nowe spotkanie z {0},
-Account Value,Wartość konta,
-Account is mandatory to get payment entries,"Konto jest obowiązkowe, aby uzyskać wpisy płatności",
-Account is not set for the dashboard chart {0},Konto nie jest ustawione dla wykresu deski rozdzielczej {0},
-Account {0} does not belong to company {1},Konto {0} nie jest przypisane do Firmy {1},
-Account {0} does not exists in the dashboard chart {1},Konto {0} nie istnieje na schemacie deski rozdzielczej {1},
-Account: <b>{0}</b> is capital Work in progress and can not be updated by Journal Entry,Konto: <b>{0}</b> to kapitał Trwają prace i nie można go zaktualizować za pomocą zapisu księgowego,
-Account: {0} is not permitted under Payment Entry,Konto: {0} jest niedozwolone w ramach wprowadzania płatności,
-Accounting Dimension <b>{0}</b> is required for 'Balance Sheet' account {1}.,Wymiar księgowy <b>{0}</b> jest wymagany dla konta „Bilans” {1}.,
-Accounting Dimension <b>{0}</b> is required for 'Profit and Loss' account {1}.,Wymiar księgowy <b>{0}</b> jest wymagany dla konta „Zysk i strata” {1}.,
-Accounting Masters,Mistrzowie rachunkowości,
-Accounting Period overlaps with {0},Okres rozliczeniowy pokrywa się z {0},
-Activity,Aktywność,
-Add / Manage Email Accounts.,Dodaj / Zarządzaj kontami poczty e-mail.,
-Add Child,Dodaj pod-element,
-Add Loan Security,Dodaj zabezpieczenia pożyczki,
-Add Multiple,Dodaj wiele,
-Add Participants,Dodaj uczestników,
-Add to Featured Item,Dodaj do polecanego elementu,
-Add your review,Dodaj swoją opinię,
-Add/Edit Coupon Conditions,Dodaj / edytuj warunki kuponu,
-Added to Featured Items,Dodano do polecanych przedmiotów,
-Added {0} ({1}),Dodano {0} ({1}),
-Address Line 1,Pierwszy wiersz adresu,
-Addresses,Adresy,
-Admission End Date should be greater than Admission Start Date.,Data zakończenia przyjęcia powinna być większa niż data rozpoczęcia przyjęcia.,
-Against Loan,Przeciw pożyczce,
-Against Loan:,Przeciw pożyczce:,
-All,Wszystko,
-All bank transactions have been created,Wszystkie transakcje bankowe zostały utworzone,
-All the depreciations has been booked,Wszystkie amortyzacje zostały zarezerwowane,
-Allocation Expired!,Przydział wygasł!,
-Allow Resetting Service Level Agreement from Support Settings.,Zezwalaj na resetowanie umowy o poziomie usług z ustawień wsparcia.,
-Amount of {0} is required for Loan closure,Kwota {0} jest wymagana do zamknięcia pożyczki,
-Amount paid cannot be zero,Kwota wypłacona nie może wynosić zero,
-Applied Coupon Code,Zastosowany kod kuponu,
-Apply Coupon Code,Wprowadź Kod Kuponu,
-Appointment Booking,Rezerwacja terminu,
-"As there are existing transactions against item {0}, you can not change the value of {1}","Ponieważ istnieje istniejące transakcje przeciwko elementu {0}, nie można zmienić wartość {1}",
-Asset Id,Identyfikator zasobu,
-Asset Value,Wartość aktywów,
-Asset Value Adjustment cannot be posted before Asset's purchase date <b>{0}</b>.,Korekta wartości aktywów nie może zostać zaksięgowana przed datą zakupu aktywów <b>{0}</b> .,
-Asset {0} does not belongs to the custodian {1},Zasób {0} nie należy do depozytariusza {1},
-Asset {0} does not belongs to the location {1},Zasób {0} nie należy do lokalizacji {1},
-At least one of the Applicable Modules should be selected,Należy wybrać co najmniej jeden z odpowiednich modułów,
-Atleast one asset has to be selected.,Należy wybrać co najmniej jeden zasób.,
-Attendance Marked,Obecność oznaczona,
-Attendance has been marked as per employee check-ins,Frekwencja została oznaczona na podstawie odprawy pracownika,
-Authentication Failed,Uwierzytelnianie nie powiodło się,
-Automatic Reconciliation,Automatyczne uzgadnianie,
-Available For Use Date,Data użycia,
-Available Stock,Dostępne zapasy,
-"Available quantity is {0}, you need {1}","Dostępna ilość to {0}, potrzebujesz {1}",
-BOM 1,LM 1,
-BOM 2,BOM 2,
-BOM Comparison Tool,Narzędzie do porównywania LM,
-BOM recursion: {0} cannot be child of {1},Rekurs BOM: {0} nie może być dzieckiem {1},
-BOM recursion: {0} cannot be parent or child of {1},Rekursja BOM: {0} nie może być rodzicem ani dzieckiem {1},
-Back to Home,Wrócić do domu,
-Back to Messages,Powrót do wiadomości,
-Bank Data mapper doesn't exist,Maper danych banku nie istnieje,
-Bank Details,Dane bankowe,
-Bank account '{0}' has been synchronized,Konto bankowe „{0}” zostało zsynchronizowane,
-Bank account {0} already exists and could not be created again,Konto bankowe {0} już istnieje i nie można go utworzyć ponownie,
-Bank accounts added,Dodano konta bankowe,
-Batch no is required for batched item {0},Nr partii jest wymagany dla pozycji wsadowej {0},
-Billing Date,Termin spłaty,
-Billing Interval Count cannot be less than 1,Liczba interwałów rozliczeniowych nie może być mniejsza niż 1,
-Blue,Niebieski,
-Book,Książka,
-Book Appointment,Umów wizytę,
-Brand,Marka,
-Browse,Przeglądaj,
-Call Connected,Połącz Połączony,
-Call Disconnected,Zadzwoń Rozłączony,
-Call Missed,Nieodebrane połączenie,
-Call Summary,Podsumowanie połączenia,
-Call Summary Saved,Podsumowanie połączeń zapisane,
-Cancelled,Anulowany,
-Cannot Calculate Arrival Time as Driver Address is Missing.,"Nie można obliczyć czasu przybycia, ponieważ brakuje adresu sterownika.",
-Cannot Optimize Route as Driver Address is Missing.,"Nie można zoptymalizować trasy, ponieważ brakuje adresu sterownika.",
-Cannot complete task {0} as its dependant task {1} are not ccompleted / cancelled.,"Nie można ukończyć zadania {0}, ponieważ jego zależne zadanie {1} nie zostało zakończone / anulowane.",
-Cannot create loan until application is approved,"Nie można utworzyć pożyczki, dopóki wniosek nie zostanie zatwierdzony",
-Cannot find a matching Item. Please select some other value for {0}.,Nie możesz znaleźć pasujący element. Proszę wybrać jakąś inną wartość dla {0}.,
-"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Nie można przepłacić za element {0} w wierszu {1} więcej niż {2}. Aby zezwolić na nadmierne fakturowanie, ustaw limit w Ustawieniach kont",
-"Capacity Planning Error, planned start time can not be same as end time","Błąd planowania wydajności, planowany czas rozpoczęcia nie może być taki sam jak czas zakończenia",
-Categories,Kategorie,
-Changes in {0},Zmiany w {0},
-Chart,Wykres,
-Choose a corresponding payment,Wybierz odpowiednią płatność,
-Click on the link below to verify your email and confirm the appointment,"Kliknij poniższy link, aby zweryfikować swój adres e-mail i potwierdzić spotkanie",
-Close,Zamknij,
-Communication,Komunikacja,
-Compact Item Print,Compact Element Drukuj,
-Company,Firma,
-Company of asset {0} and purchase document {1} doesn't matches.,Firma zasobu {0} i dokument zakupu {1} nie pasują.,
-Compare BOMs for changes in Raw Materials and Operations,Porównaj LM dla zmian w surowcach i operacjach,
-Compare List function takes on list arguments,Funkcja listy porównawczej przyjmuje argumenty listy,
-Complete,Kompletny,
-Completed,Zakończono,
-Completed Quantity,Ukończona ilość,
-Connect your Exotel Account to ERPNext and track call logs,Połącz swoje konto Exotel z ERPNext i śledź dzienniki połączeń,
-Connect your bank accounts to ERPNext,Połącz swoje konta bankowe z ERPNext,
-Contact Seller,Skontaktuj się ze sprzedawcą,
-Continue,Kontynuuj,
-Cost Center: {0} does not exist,Centrum kosztów: {0} nie istnieje,
-Couldn't Set Service Level Agreement {0}.,Nie można ustawić umowy o poziomie usług {0}.,
-Country,Kraj,
-Country Code in File does not match with country code set up in the system,Kod kraju w pliku nie zgadza się z kodem kraju skonfigurowanym w systemie,
-Create New Contact,Utwórz nowy kontakt,
-Create New Lead,Utwórz nowego potencjalnego klienta,
-Create Pick List,Utwórz listę wyboru,
-Create Quality Inspection for Item {0},Utwórz kontrolę jakości dla przedmiotu {0},
-Creating Accounts...,Tworzenie kont ...,
-Creating bank entries...,Tworzenie wpisów bankowych ...,
-Credit limit is already defined for the Company {0},Limit kredytowy jest już zdefiniowany dla firmy {0},
-Ctrl + Enter to submit,"Ctrl + Enter, aby przesłać",
-Ctrl+Enter to submit,"Ctrl + Enter, aby przesłać",
-Currency,Waluta,
-Current Status,Bieżący status,
-Customer PO,Klient PO,
-Customize,Dostosuj,
-Daily,Codziennie,
-Date,Data,
-Date Range,Zakres dat,
-Date of Birth cannot be greater than Joining Date.,Data urodzenia nie może być większa niż data przystąpienia.,
-Dear,Drogi,
-Default,Domyślny,
-Define coupon codes.,Zdefiniuj kody kuponów.,
-Delayed Days,Opóźnione dni,
-Delete,Usuń,
-Delivered Quantity,Dostarczona ilość,
-Delivery Notes,Dokumenty dostawy,
-Depreciated Amount,Amortyzowana kwota,
-Description,Opis,
-Designation,Nominacja,
-Difference Value,Różnica wartości,
-Dimension Filter,Filtr wymiarów,
-Disabled,Nieaktywny,
-Disbursement and Repayment,Wypłata i spłata,
-Distance cannot be greater than 4000 kms,Odległość nie może być większa niż 4000 km,
-Do you want to submit the material request,Czy chcesz przesłać żądanie materiałowe,
-Doctype,Doctype,
-Document {0} successfully uncleared,Dokument {0} został pomyślnie usunięty,
-Download Template,Ściągnij Szablon,
-Dr,Dr,
-Due Date,Termin,
-Duplicate,Powiel,
-Duplicate Project with Tasks,Duplikuj projekt z zadaniami,
-Duplicate project has been created,Utworzono zduplikowany projekt,
-E-Way Bill JSON can only be generated from a submitted document,e-Way Bill JSON można wygenerować tylko z przesłanego dokumentu,
-E-Way Bill JSON can only be generated from submitted document,e-Way Bill JSON można wygenerować tylko z przesłanego dokumentu,
-E-Way Bill JSON cannot be generated for Sales Return as of now,e-Way Bill JSON nie może być teraz generowany dla zwrotu sprzedaży,
-ERPNext could not find any matching payment entry,ERPNext nie mógł znaleźć żadnego pasującego wpisu płatności,
-Earliest Age,Najwcześniejszy wiek,
-Edit Details,Edytuj szczegóły,
-Edit Profile,Edytuj profil,
-Either GST Transporter ID or Vehicle No is required if Mode of Transport is Road,"Wymagany jest identyfikator transportera GST lub nr pojazdu, jeśli tryb transportu to Droga",
-Email,E-mail,
-Email Campaigns,Kampanie e-mail,
-Employee ID is linked with another instructor,Identyfikator pracownika jest powiązany z innym instruktorem,
-Employee Tax and Benefits,Podatek i świadczenia pracownicze,
-Employee is required while issuing Asset {0},Wymagany jest pracownik przy wydawaniu środka trwałego {0},
-Employee {0} does not belongs to the company {1},Pracownik {0} nie należy do firmy {1},
-Enable Auto Re-Order,Włącz automatyczne ponowne zamówienie,
-End Date of Agreement can't be less than today.,Data zakończenia umowy nie może być mniejsza niż dzisiaj.,
-End Time,Czas zakończenia,
-Energy Point Leaderboard,Tabela punktów energetycznych,
-Enter API key in Google Settings.,Wprowadź klucz API w Ustawieniach Google.,
-Enter Supplier,Wpisz dostawcę,
-Enter Value,Wpisz Wartość,
-Entity Type,Typ encji,
-Error,Błąd,
-Error in Exotel incoming call,Błąd połączenia przychodzącego Exotel,
-Error: {0} is mandatory field,Błąd: {0} to pole obowiązkowe,
-Event Link,Link do wydarzenia,
-Exception occurred while reconciling {0},Wystąpił wyjątek podczas uzgadniania {0},
-Expected and Discharge dates cannot be less than Admission Schedule date,Oczekiwana data i data zwolnienia nie mogą być krótsze niż data harmonogramu przyjęć,
-Expire Allocation,Wygaś przydział,
-Expired,Upłynął,
-Export,Eksport,
-Export not allowed. You need {0} role to export.,eksport nie jest dozwolony. Potrzebujesz {0} modeli żeby eksportować,
-Failed to add Domain,Nie udało się dodać domeny,
-Fetch Items from Warehouse,Pobierz przedmioty z magazynu,
-Fetching...,Ujmujący...,
-Field,Pole,
-File Manager,Menedżer plików,
-Filters,Filtry,
-Finding linked payments,Znajdowanie powiązanych płatności,
-Fleet Management,Fleet Management,
-Following fields are mandatory to create address:,"Aby utworzyć adres, należy podać następujące pola:",
-For Month,Na miesiąc,
-"For item {0} at row {1}, count of serial numbers does not match with the picked quantity",Dla pozycji {0} w wierszu {1} liczba numerów seryjnych nie zgadza się z pobraną ilością,
-For operation {0}: Quantity ({1}) can not be greter than pending quantity({2}),Dla operacji {0}: Ilość ({1}) nie może być greter wyższa niż ilość oczekująca ({2}),
-For quantity {0} should not be greater than work order quantity {1},Dla ilości {0} nie powinna być większa niż ilość zlecenia pracy {1},
-Free item not set in the pricing rule {0},Darmowy element nie jest ustawiony w regule cenowej {0},
-From Date and To Date are Mandatory,Od daty i daty są obowiązkowe,
-From employee is required while receiving Asset {0} to a target location,Od pracownika jest wymagany przy odbiorze Zasoby {0} do docelowej lokalizacji,
-Fuel Expense,Koszt paliwa,
-Future Payment Amount,Kwota przyszłej płatności,
-Future Payment Ref,Przyszła płatność Nr ref,
-Future Payments,Przyszłe płatności,
-GST HSN Code does not exist for one or more items,Kod GST HSN nie istnieje dla jednego lub więcej przedmiotów,
-Generate E-Way Bill JSON,Generuj e-Way Bill JSON,
-Get Items,Pobierz,
-Get Outstanding Documents,Uzyskaj znakomite dokumenty,
-Goal,Cel,
-Greater Than Amount,Większa niż kwota,
-Green,Zielony,
-Group,Grupa,
-Group By Customer,Grupuj według klienta,
-Group By Supplier,Grupuj według dostawcy,
-Group Node,Węzeł Grupy,
-Group Warehouses cannot be used in transactions. Please change the value of {0},Magazyny grupowe nie mogą być używane w transakcjach. Zmień wartość {0},
-Help,Pomoc,
-Help Article,Artykuł pomocy,
-"Helps you keep tracks of Contracts based on Supplier, Customer and Employee","Pomaga śledzić kontrakty na podstawie dostawcy, klienta i pracownika",
-Helps you manage appointments with your leads,Pomaga zarządzać spotkaniami z potencjalnymi klientami,
-Home,Start,
-IBAN is not valid,IBAN jest nieprawidłowy,
-Import Data from CSV / Excel files.,Importuj dane z plików CSV / Excel.,
-In Progress,W trakcie,
-Incoming call from {0},Połączenie przychodzące od {0},
-Incorrect Warehouse,Niepoprawny magazyn,
-Intermediate,Pośredni,
-Invalid Barcode. There is no Item attached to this barcode.,Nieprawidłowy kod kreskowy. Brak kodu dołączonego do tego kodu kreskowego.,
-Invalid credentials,Nieprawidłowe poświadczenia,
-Invite as User,Zaproś jako Użytkownik,
-Issue Priority.,Priorytet wydania.,
-Issue Type.,Typ problemu.,
-"It seems that there is an issue with the server's stripe configuration. In case of failure, the amount will get refunded to your account.","Wygląda na to, że istnieje problem z konfiguracją pasków serwera. W przypadku niepowodzenia kwota zostanie zwrócona na Twoje konto.",
-Item Reported,Zgłoszony element,
-Item listing removed,Usunięto listę produktów,
-Item quantity can not be zero,Ilość towaru nie może wynosić zero,
-Item taxes updated,Zaktualizowano podatki od towarów,
-Item {0}: {1} qty produced. ,Produkt {0}: wyprodukowano {1} sztuk.,
-Joining Date can not be greater than Leaving Date,Data dołączenia nie może być większa niż Data opuszczenia,
-Lab Test Item {0} already exist,Element testu laboratoryjnego {0} już istnieje,
-Last Issue,Ostatnie wydanie,
-Latest Age,Późne stadium,
-Leave application is linked with leave allocations {0}. Leave application cannot be set as leave without pay,Wniosek o urlop jest powiązany z przydziałem urlopu {0}. Wniosek o urlop nie może być ustawiony jako urlop bez wynagrodzenia,
-Leaves Taken,Zrobione liście,
-Less Than Amount,Mniej niż kwota,
-Liabilities,Zadłużenie,
-Loading...,Wczytuję...,
-Loan Amount exceeds maximum loan amount of {0} as per proposed securities,Kwota pożyczki przekracza maksymalną kwotę pożyczki w wysokości {0} zgodnie z proponowanymi papierami wartościowymi,
-Loan Applications from customers and employees.,Wnioski o pożyczkę od klientów i pracowników.,
-Loan Disbursement,Wypłata pożyczki,
-Loan Processes,Procesy pożyczkowe,
-Loan Security,Zabezpieczenie pożyczki,
-Loan Security Pledge,Zobowiązanie do zabezpieczenia pożyczki,
-Loan Security Pledge Created : {0},Utworzono zastaw na zabezpieczeniu pożyczki: {0},
-Loan Security Price,Cena zabezpieczenia pożyczki,
-Loan Security Price overlapping with {0},Cena zabezpieczenia kredytu pokrywająca się z {0},
-Loan Security Unpledge,Zabezpieczenie pożyczki Unpledge,
-Loan Security Value,Wartość zabezpieczenia pożyczki,
-Loan Type for interest and penalty rates,Rodzaj pożyczki na odsetki i kary pieniężne,
-Loan amount cannot be greater than {0},Kwota pożyczki nie może być większa niż {0},
-Loan is mandatory,Pożyczka jest obowiązkowa,
-Loans,Pożyczki,
-Loans provided to customers and employees.,Pożyczki udzielone klientom i pracownikom.,
-Location,Lokacja,
-Log Type is required for check-ins falling in the shift: {0}.,Typ dziennika jest wymagany w przypadku zameldowań przypadających na zmianę: {0}.,
-Looks like someone sent you to an incomplete URL. Please ask them to look into it.,"Wygląda jak ktoś wysłał do niekompletnego adresu URL. Proszę poprosić ich, aby na nią patrzeć.",
-Make Journal Entry,Dodaj wpis do dziennika,
-Make Purchase Invoice,Nowa faktura zakupu,
-Manufactured,Zrobiony fabrycznie,
-Mark Work From Home,Oznacz pracę z domu,
-Master,Magister,
-Max strength cannot be less than zero.,Maksymalna siła nie może być mniejsza niż zero.,
-Maximum attempts for this quiz reached!,Osiągnięto maksymalną liczbę prób tego quizu!,
-Message,Wiadomość,
-Missing Values Required,Uzupełnij Brakujące Wartości,
-Mobile No,Nr tel. Komórkowego,
-Mobile Number,Numer telefonu komórkowego,
-Month,Miesiąc,
-Name,Nazwa,
-Near you,Blisko Ciebie,
-Net Profit/Loss,Zysk / strata netto,
-New Expense,Nowy wydatek,
-New Invoice,Nowa faktura,
-New Payment,Nowa płatność,
-New release date should be in the future,Nowa data wydania powinna być w przyszłości,
-Newsletter,Newsletter,
-No Account matched these filters: {},Brak kont pasujących do tych filtrów: {},
-No Employee found for the given employee field value. '{}': {},Nie znaleziono pracownika dla danej wartości pola pracownika. &#39;{}&#39;: {},
-No Leaves Allocated to Employee: {0} for Leave Type: {1},Brak urlopów przydzielonych pracownikowi: {0} dla typu urlopu: {1},
-No communication found.,Nie znaleziono komunikacji.,
-No correct answer is set for {0},Brak poprawnej odpowiedzi dla {0},
-No description,Bez opisu,
-No issue has been raised by the caller.,Dzwoniący nie podniósł żadnego problemu.,
-No items to publish,Brak elementów do opublikowania,
-No outstanding invoices found,Nie znaleziono żadnych zaległych faktur,
-No outstanding invoices found for the {0} {1} which qualify the filters you have specified.,"Nie znaleziono zaległych faktur za {0} {1}, które kwalifikują określone filtry.",
-No outstanding invoices require exchange rate revaluation,Żadne zaległe faktury nie wymagają aktualizacji kursu walutowego,
-No reviews yet,Brak recenzji,
-No views yet,Brak jeszcze wyświetleń,
-Non stock items,Pozycje niedostępne,
-Not Allowed,Nie dozwolone,
-Not allowed to create accounting dimension for {0},Nie wolno tworzyć wymiaru księgowego dla {0},
-Not permitted. Please disable the Lab Test Template,Nie dozwolone. Wyłącz szablon testu laboratoryjnego,
-Note,Notatka,
-Notes: ,Notatki:,
-On Converting Opportunity,O możliwościach konwersji,
-On Purchase Order Submission,Po złożeniu zamówienia,
-On Sales Order Submission,Przy składaniu zamówienia sprzedaży,
-On Task Completion,Po zakończeniu zadania,
-On {0} Creation,W dniu {0} Creation,
-Only .csv and .xlsx files are supported currently,Aktualnie obsługiwane są tylko pliki .csv i .xlsx,
-Only expired allocation can be cancelled,Tylko wygasły przydział można anulować,
-Only users with the {0} role can create backdated leave applications,Tylko użytkownicy z rolą {0} mogą tworzyć aplikacje urlopowe z datą wsteczną,
-Open,otwarty,
-Open Contact,Otwarty kontakt,
-Open Lead,Ołów otwarty,
-Opening and Closing,Otwieranie i zamykanie,
-Operating Cost as per Work Order / BOM,Koszt operacyjny według zlecenia pracy / BOM,
-Order Amount,Kwota zamówienia,
-Page {0} of {1},Strona {0} z {1},
-Paid amount cannot be less than {0},Kwota wpłaty nie może być mniejsza niż {0},
-Parent Company must be a group company,Firma macierzysta musi być spółką grupy,
-Passing Score value should be between 0 and 100,Wartość Passing Score powinna wynosić od 0 do 100,
-Password policy cannot contain spaces or simultaneous hyphens. The format will be restructured automatically,Polityka haseł nie może zawierać spacji ani jednoczesnych myślników. Format zostanie automatycznie zrestrukturyzowany,
-Patient History,Historia pacjenta,
-Pause,Pauza,
-Pay,Zapłacone,
-Payment Document Type,Typ dokumentu płatności,
-Payment Name,Nazwa płatności,
-Penalty Amount,Kwota kary,
-Pending,W toku,
-Performance,Występ,
-Period based On,Okres oparty na,
-Perpetual inventory required for the company {0} to view this report.,"Aby przeglądać ten raport, firma musi mieć ciągłe zapasy.",
-Phone,Telefon,
-Pick List,Lista wyboru,
-Plaid authentication error,Błąd uwierzytelniania w kratkę,
-Plaid public token error,Błąd publicznego znacznika w kratkę,
-Plaid transactions sync error,Błąd synchronizacji transakcji Plaid,
-Please check the error log for details about the import errors,"Sprawdź dziennik błędów, aby uzyskać szczegółowe informacje na temat błędów importu",
-Please create <b>DATEV Settings</b> for Company <b>{}</b>.,<b>Utwórz ustawienia DATEV</b> dla firmy <b>{}</b> .,
-Please create adjustment Journal Entry for amount {0} ,Utwórz korektę Zapis księgowy dla kwoty {0},
-Please do not create more than 500 items at a time,Nie twórz więcej niż 500 pozycji naraz,
-Please enter <b>Difference Account</b> or set default <b>Stock Adjustment Account</b> for company {0},Wprowadź <b>konto różnicowe</b> lub ustaw domyślne <b>konto korekty zapasów</b> dla firmy {0},
-Please enter GSTIN and state for the Company Address {0},Wprowadź GSTIN i podaj adres firmy {0},
-Please enter Item Code to get item taxes,"Wprowadź kod produktu, aby otrzymać podatki od przedmiotu",
-Please enter Warehouse and Date,Proszę podać Magazyn i datę,
-Please enter the designation,Proszę podać oznaczenie,
-Please login as a Marketplace User to edit this item.,"Zaloguj się jako użytkownik Marketplace, aby edytować ten element.",
-Please login as a Marketplace User to report this item.,"Zaloguj się jako użytkownik Marketplace, aby zgłosić ten element.",
-Please select <b>Template Type</b> to download template,"Wybierz <b>Typ szablonu,</b> aby pobrać szablon",
-Please select Applicant Type first,Najpierw wybierz typ wnioskodawcy,
-Please select Customer first,Najpierw wybierz klienta,
-Please select Item Code first,Najpierw wybierz Kod produktu,
-Please select Loan Type for company {0},Wybierz typ pożyczki dla firmy {0},
-Please select a Delivery Note,Wybierz dowód dostawy,
-Please select a Sales Person for item: {0},Wybierz sprzedawcę dla produktu: {0},
-Please select another payment method. Stripe does not support transactions in currency '{0}',Wybierz inną metodę płatności. Stripe nie obsługuje transakcji w walucie &#39;{0}&#39;,
-Please select the customer.,Wybierz klienta.,
-Please set a Supplier against the Items to be considered in the Purchase Order.,"Proszę ustawić Dostawcę na tle Przedmiotów, które należy uwzględnić w Zamówieniu.",
-Please set account heads in GST Settings for Compnay {0},Ustaw głowice kont w Ustawieniach GST dla Compnay {0},
-Please set an email id for the Lead {0},Ustaw identyfikator e-mail dla potencjalnego klienta {0},
-Please set default UOM in Stock Settings,Proszę ustawić domyślną JM w Ustawieniach magazynowych,
-Please set filter based on Item or Warehouse due to a large amount of entries.,Ustaw filtr na podstawie pozycji lub magazynu ze względu na dużą liczbę wpisów.,
-Please set up the Campaign Schedule in the Campaign {0},Ustaw harmonogram kampanii w kampanii {0},
-Please set valid GSTIN No. in Company Address for company {0},Ustaw prawidłowy numer GSTIN w adresie firmy dla firmy {0},
-Please set {0},Ustaw {0},customer
-Please setup a default bank account for company {0},Ustaw domyślne konto bankowe dla firmy {0},
-Please specify,Sprecyzuj,
-Please specify a {0},Proszę podać {0},lead
-Pledge Status,Status zobowiązania,
-Pledge Time,Czas przyrzeczenia,
-Printing,Druk,
-Priority,Priorytet,
-Priority has been changed to {0}.,Priorytet został zmieniony na {0}.,
-Priority {0} has been repeated.,Priorytet {0} został powtórzony.,
-Processing XML Files,Przetwarzanie plików XML,
-Profitability,Rentowność,
-Project,Projekt,
-Proposed Pledges are mandatory for secured Loans,Proponowane zastawy są obowiązkowe dla zabezpieczonych pożyczek,
-Provide the academic year and set the starting and ending date.,Podaj rok akademicki i ustaw datę początkową i końcową.,
-Public token is missing for this bank,Brakuje publicznego tokena dla tego banku,
-Publish,Publikować,
-Publish 1 Item,Opublikuj 1 przedmiot,
-Publish Items,Publikuj przedmioty,
-Publish More Items,Opublikuj więcej przedmiotów,
-Publish Your First Items,Opublikuj swoje pierwsze przedmioty,
-Publish {0} Items,Opublikuj {0} przedmiotów,
-Published Items,Opublikowane przedmioty,
-Purchase Invoice cannot be made against an existing asset {0},Nie można wystawić faktury zakupu na istniejący zasób {0},
-Purchase Invoices,Faktury zakupu,
-Purchase Orders,Zlecenia kupna,
-Purchase Receipt doesn't have any Item for which Retain Sample is enabled.,"W potwierdzeniu zakupu nie ma żadnego elementu, dla którego włączona jest opcja Zachowaj próbkę.",
-Purchase Return,Zwrot zakupu,
-Qty of Finished Goods Item,Ilość produktu gotowego,
-Qty or Amount is mandatroy for loan security,Ilość lub Kwota jest mandatroy dla zabezpieczenia kredytu,
-Quality Inspection required for Item {0} to submit,Kontrola jakości wymagana do przesłania pozycji {0},
-Quantity to Manufacture,Ilość do wyprodukowania,
-Quantity to Manufacture can not be zero for the operation {0},Ilość do wyprodukowania nie może wynosić zero dla operacji {0},
-Quarterly,Kwartalnie,
-Queued,W kolejce,
-Quick Entry,Szybkie wejścia,
-Quiz {0} does not exist,Quiz {0} nie istnieje,
-Quotation Amount,Kwota oferty,
-Rate or Discount is required for the price discount.,Do obniżki ceny wymagana jest stawka lub zniżka.,
-Reason,Powód,
-Reconcile Entries,Uzgodnij wpisy,
-Reconcile this account,Uzgodnij to konto,
-Reconciled,Uzgodnione,
-Recruitment,Rekrutacja,
-Red,Czerwony,
-Refreshing,Odświeżam,
-Release date must be in the future,Data wydania musi być w przyszłości,
-Relieving Date must be greater than or equal to Date of Joining,Data zwolnienia musi być większa lub równa dacie przystąpienia,
-Rename,Zmień nazwę,
-Rename Not Allowed,Zmień nazwę na Niedozwolone,
-Repayment Method is mandatory for term loans,Metoda spłaty jest obowiązkowa w przypadku pożyczek terminowych,
-Repayment Start Date is mandatory for term loans,Data rozpoczęcia spłaty jest obowiązkowa w przypadku pożyczek terminowych,
-Report Item,Zgłoś przedmiot,
-Report this Item,Zgłoś ten przedmiot,
-Reserved Qty for Subcontract: Raw materials quantity to make subcontracted items.,Zarezerwowana ilość dla umowy podwykonawczej: ilość surowców do wytworzenia elementów podwykonawczych.,
-Reset,Nastawić,
-Reset Service Level Agreement,Zresetuj umowę o poziomie usług,
-Resetting Service Level Agreement.,Resetowanie umowy o poziomie usług.,
-Return amount cannot be greater unclaimed amount,Kwota zwrotu nie może być większa niż kwota nieodebrana,
-Review,Przejrzeć,
-Room,Pokój,
-Room Type,Rodzaj pokoju,
-Row # ,Wiersz #,
-Row #{0}: Accepted Warehouse and Supplier Warehouse cannot be same,Wiersz # {0}: Magazyn zaakceptowany i magazyn dostawcy nie mogą być takie same,
-Row #{0}: Cannot delete item {1} which has already been billed.,"Wiersz # {0}: Nie można usunąć elementu {1}, który został już rozliczony.",
-Row #{0}: Cannot delete item {1} which has already been delivered,"Wiersz # {0}: Nie można usunąć elementu {1}, który został już dostarczony",
-Row #{0}: Cannot delete item {1} which has already been received,"Wiersz # {0}: Nie można usunąć elementu {1}, który został już odebrany",
-Row #{0}: Cannot delete item {1} which has work order assigned to it.,"Wiersz # {0}: Nie można usunąć elementu {1}, któremu przypisano zlecenie pracy.",
-Row #{0}: Cannot delete item {1} which is assigned to customer's purchase order.,"Wiersz # {0}: Nie można usunąć elementu {1}, który jest przypisany do zamówienia zakupu klienta.",
-Row #{0}: Cannot select Supplier Warehouse while suppling raw materials to subcontractor,Wiersz # {0}: nie można wybrać magazynu dostawcy podczas dostarczania surowców do podwykonawcy,
-Row #{0}: Cost Center {1} does not belong to company {2},Wiersz # {0}: Centrum kosztów {1} nie należy do firmy {2},
-Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order {3}. Please update operation status via Job Card {4}.,Wiersz # {0}: operacja {1} nie została zakończona dla {2} ilości gotowych produktów w zleceniu pracy {3}. Zaktualizuj status operacji za pomocą karty pracy {4}.,
-Row #{0}: Payment document is required to complete the transaction,Wiersz # {0}: dokument płatności jest wymagany do zakończenia transakcji,
-Row #{0}: Serial No {1} does not belong to Batch {2},Wiersz # {0}: numer seryjny {1} nie należy do partii {2},
-Row #{0}: Service End Date cannot be before Invoice Posting Date,Wiersz # {0}: data zakończenia usługi nie może być wcześniejsza niż data księgowania faktury,
-Row #{0}: Service Start Date cannot be greater than Service End Date,Wiersz # {0}: data rozpoczęcia usługi nie może być większa niż data zakończenia usługi,
-Row #{0}: Service Start and End Date is required for deferred accounting,Wiersz # {0}: data rozpoczęcia i zakończenia usługi jest wymagana dla odroczonej księgowości,
-Row {0}: Invalid Item Tax Template for item {1},Wiersz {0}: nieprawidłowy szablon podatku od towarów dla towaru {1},
-Row {0}: Quantity not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Wiersz {0}: ilość niedostępna dla {4} w magazynie {1} w czasie księgowania wpisu ({2} {3}),
-Row {0}: user has not applied the rule {1} on the item {2},Wiersz {0}: użytkownik nie zastosował reguły {1} do pozycji {2},
-Row {0}:Sibling Date of Birth cannot be greater than today.,Wiersz {0}: data urodzenia rodzeństwa nie może być większa niż dzisiaj.,
-Row({0}): {1} is already discounted in {2},Wiersz ({0}): {1} jest już zdyskontowany w {2},
-Rows Added in {0},Rzędy dodane w {0},
-Rows Removed in {0},Rzędy usunięte w {0},
-Sanctioned Amount limit crossed for {0} {1},Przekroczono limit kwoty usankcjonowanej dla {0} {1},
-Sanctioned Loan Amount already exists for {0} against company {1},Kwota sankcjonowanej pożyczki już istnieje dla {0} wobec firmy {1},
-Save,Zapisz,
-Save Item,Zapisz przedmiot,
-Saved Items,Zapisane przedmioty,
-Search Items ...,Szukaj przedmiotów ...,
-Search for a payment,Wyszukaj płatność,
-Search for anything ...,Wyszukaj cokolwiek ...,
-Search results for,Wyniki wyszukiwania dla,
-Select All,Wybierz wszystko,
-Select Difference Account,Wybierz konto różnicy,
-Select a Default Priority.,Wybierz domyślny priorytet.,
-Select a company,Wybierz firmę,
-Select finance book for the item {0} at row {1},Wybierz księgę finansową dla pozycji {0} w wierszu {1},
-Select only one Priority as Default.,Wybierz tylko jeden priorytet jako domyślny.,
-Seller Information,Informacje o sprzedawcy,
-Send,Wyślij,
-Send a message,Wysłać wiadomość,
-Sending,Wysyłanie,
-Sends Mails to lead or contact based on a Campaign schedule,Wysyła wiadomości e-mail do potencjalnego klienta lub kontaktu na podstawie harmonogramu kampanii,
-Serial Number Created,Utworzono numer seryjny,
-Serial Numbers Created,Utworzono numery seryjne,
-Serial no(s) required for serialized item {0},Nie są wymagane numery seryjne dla pozycji zserializowanej {0},
-Series,Seria,
-Server Error,błąd serwera,
-Service Level Agreement has been changed to {0}.,Umowa o poziomie usług została zmieniona na {0}.,
-Service Level Agreement was reset.,Umowa o poziomie usług została zresetowana.,
-Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Umowa o poziomie usług z typem podmiotu {0} i podmiotem {1} już istnieje.,
-Set,Zbiór,
-Set Meta Tags,Ustaw meta tagi,
-Set {0} in company {1},Ustaw {0} w firmie {1},
-Setup,Ustawienia,
-Setup Wizard,Ustawienia Wizard,
-Shift Management,Zarządzanie zmianą,
-Show Future Payments,Pokaż przyszłe płatności,
-Show Linked Delivery Notes,Pokaż połączone dowody dostawy,
-Show Sales Person,Pokaż sprzedawcę,
-Show Stock Ageing Data,Pokaż dane dotyczące starzenia się zapasów,
-Show Warehouse-wise Stock,Pokaż magazyn w magazynie,
-Size,Rozmiar,
-Something went wrong while evaluating the quiz.,Coś poszło nie tak podczas oceny quizu.,
-Sr,sr,
-Start,Start,
-Start Date cannot be before the current date,Data rozpoczęcia nie może być wcześniejsza niż bieżąca data,
-Start Time,Czas rozpoczęcia,
-Status,Status,
-Status must be Cancelled or Completed,Status musi zostać anulowany lub ukończony,
-Stock Balance Report,Raport stanu zapasów,
-Stock Entry has been already created against this Pick List,Zapis zapasów został już utworzony dla tej listy pobrania,
-Stock Ledger ID,Identyfikator księgi głównej,
-Stock Value ({0}) and Account Balance ({1}) are out of sync for account {2} and it's linked warehouses.,Wartość zapasów ({0}) i saldo konta ({1}) nie są zsynchronizowane dla konta {2} i powiązanych magazynów.,
-Stores - {0},Sklepy - {0},
-Student with email {0} does not exist,Student z e-mailem {0} nie istnieje,
-Submit Review,Dodaj recenzję,
-Submitted,Zgłoszny,
-Supplier Addresses And Contacts,Adresy i kontakty dostawcy,
-Synchronize this account,Zsynchronizuj to konto,
-Tag,Etykietka,
-Target Location is required while receiving Asset {0} from an employee,Lokalizacja docelowa jest wymagana podczas otrzymywania środka {0} od pracownika,
-Target Location is required while transferring Asset {0},Lokalizacja docelowa jest wymagana podczas przenoszenia aktywów {0},
-Target Location or To Employee is required while receiving Asset {0},Lokalizacja docelowa lub Do pracownika jest wymagana podczas otrzymywania Zasobu {0},
-Task's {0} End Date cannot be after Project's End Date.,Data zakończenia zadania {0} nie może być późniejsza niż data zakończenia projektu.,
-Task's {0} Start Date cannot be after Project's End Date.,Data rozpoczęcia zadania {0} nie może być późniejsza niż data zakończenia projektu.,
-Tax Account not specified for Shopify Tax {0},Nie określono konta podatkowego dla Shopify Tax {0},
-Tax Total,Podatek ogółem,
-Template,Szablon,
-The Campaign '{0}' already exists for the {1} '{2}',Kampania „{0}” już istnieje dla {1} ”{2}”,
-The difference between from time and To Time must be a multiple of Appointment,Różnica między czasem a czasem musi być wielokrotnością terminu,
-The field Asset Account cannot be blank,Pole Konto aktywów nie może być puste,
-The field Equity/Liability Account cannot be blank,Pole Rachunek kapitału własnego / pasywnego nie może być puste,
-The following serial numbers were created: <br><br> {0},Utworzono następujące numery seryjne: <br><br> {0},
-The parent account {0} does not exists in the uploaded template,Konto nadrzędne {0} nie istnieje w przesłanym szablonie,
-The question cannot be duplicate,Pytanie nie może być duplikowane,
-The selected payment entry should be linked with a creditor bank transaction,Wybrany zapis płatności powinien być powiązany z transakcją banku wierzyciela,
-The selected payment entry should be linked with a debtor bank transaction,Wybrany zapis płatności powinien być powiązany z transakcją bankową dłużnika,
-The total allocated amount ({0}) is greated than the paid amount ({1}).,Łączna przydzielona kwota ({0}) jest przywitana niż wypłacona kwota ({1}).,
-There are no vacancies under staffing plan {0},W planie zatrudnienia nie ma wolnych miejsc pracy {0},
-This Service Level Agreement is specific to Customer {0},Niniejsza umowa dotycząca poziomu usług dotyczy wyłącznie klienta {0},
-This action will unlink this account from any external service integrating ERPNext with your bank accounts. It cannot be undone. Are you certain ?,Ta czynność spowoduje odłączenie tego konta od dowolnej usługi zewnętrznej integrującej ERPNext z kontami bankowymi. Nie można tego cofnąć. Czy jesteś pewien ?,
-This bank account is already synchronized,To konto bankowe jest już zsynchronizowane,
-This bank transaction is already fully reconciled,Ta transakcja bankowa została już w pełni uzgodniona,
-This employee already has a log with the same timestamp.{0},Ten pracownik ma już dziennik z tym samym znacznikiem czasu. {0},
-This page keeps track of items you want to buy from sellers.,"Ta strona śledzi przedmioty, które chcesz kupić od sprzedawców.",
-This page keeps track of your items in which buyers have showed some interest.,"Ta strona śledzi Twoje produkty, którymi kupujący wykazali pewne zainteresowanie.",
-Thursday,Czwartek,
-Timing,wyczucie czasu,
-Title,Tytuł,
-"To allow over billing, update ""Over Billing Allowance"" in Accounts Settings or the Item.","Aby zezwolić na rozliczenia, zaktualizuj „Over Billing Allowance” w ustawieniach kont lub pozycji.",
-"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Aby zezwolić na odbiór / dostawę, zaktualizuj „Przekazywanie / dostawę” w Ustawieniach magazynowych lub pozycji.",
-To date needs to be before from date,Do tej pory musi być wcześniejsza niż data,
-Total,Razem,
-Total Early Exits,Łącznie wczesne wyjścia,
-Total Late Entries,Późne wpisy ogółem,
-Total Payment Request amount cannot be greater than {0} amount,Łączna kwota żądania zapłaty nie może być większa niż kwota {0},
-Total payments amount can't be greater than {},Łączna kwota płatności nie może być większa niż {},
-Totals,Sumy całkowite,
-Training Event:,Wydarzenie szkoleniowe:,
-Transactions already retreived from the statement,Transakcje już wycofane z wyciągu,
-Transfer Material to Supplier,Przenieść materiał do dostawcy,
-Transport Receipt No and Date are mandatory for your chosen Mode of Transport,Nr potwierdzenia odbioru i data są obowiązkowe w wybranym trybie transportu,
-Tuesday,Wtorek,
-Type,Typ,
-Unable to find Salary Component {0},Nie można znaleźć składnika wynagrodzenia {0},
-Unable to find the time slot in the next {0} days for the operation {1}.,Nie można znaleźć przedziału czasu w ciągu najbliższych {0} dni dla operacji {1}.,
-Unable to update remote activity,Nie można zaktualizować aktywności zdalnej,
-Unknown Caller,Nieznany rozmówca,
-Unlink external integrations,Rozłącz integracje zewnętrzne,
-Unmarked Attendance for days,Nieoznakowana obecność na kilka dni,
-Unpublish Item,Cofnij publikację przedmiotu,
-Unreconciled,Nieuzgodnione,
-Unsupported GST Category for E-Way Bill JSON generation,Nieobsługiwana kategoria GST dla generacji e-Way Bill JSON,
-Update,Aktualizacja,
-Update Details,Zaktualizuj szczegóły,
-Update Taxes for Items,Zaktualizuj podatki od przedmiotów,
-"Upload a bank statement, link or reconcile a bank account","Prześlij wyciąg z konta bankowego, połącz lub rozlicz konto bankowe",
-Upload a statement,Prześlij oświadczenie,
-Use a name that is different from previous project name,Użyj nazwy innej niż nazwa poprzedniego projektu,
-User {0} is disabled,Użytkownik {0} jest wyłączony,
-Users and Permissions,Użytkownicy i uprawnienia,
-Vacancies cannot be lower than the current openings,Wolne miejsca nie mogą być niższe niż obecne otwarcia,
-Valid From Time must be lesser than Valid Upto Time.,Ważny od czasu musi być mniejszy niż Ważny do godziny.,
-Valuation Rate required for Item {0} at row {1},Kurs wyceny wymagany dla pozycji {0} w wierszu {1},
-Values Out Of Sync,Wartości niezsynchronizowane,
-Vehicle Type is required if Mode of Transport is Road,"Typ pojazdu jest wymagany, jeśli tryb transportu to Droga",
-Vendor Name,Nazwa dostawcy,
-Verify Email,zweryfikuj adres e-mail,
-View,Widok,
-View all issues from {0},Wyświetl wszystkie problemy z {0},
-View call log,Wyświetl dziennik połączeń,
-Warehouse,Magazyn,
-Warehouse not found against the account {0},Nie znaleziono magazynu dla konta {0},
-Welcome to {0},Zapraszamy do {0},
-Why do think this Item should be removed?,Dlaczego według mnie ten przedmiot powinien zostać usunięty?,
-Work Order {0}: Job Card not found for the operation {1},Zlecenie pracy {0}: Nie znaleziono karty pracy dla operacji {1},
-Workday {0} has been repeated.,Dzień roboczy {0} został powtórzony.,
-XML Files Processed,Przetwarzane pliki XML,
-Year,Rok,
-Yearly,Rocznie,
-You,Ty,
-You are not allowed to enroll for this course,Nie możesz zapisać się na ten kurs,
-You are not enrolled in program {0},Nie jesteś zarejestrowany w programie {0},
-You can Feature upto 8 items.,Możesz polecić do 8 przedmiotów.,
-You can also copy-paste this link in your browser,Można również skopiować i wkleić ten link w przeglądarce,
-You can publish upto 200 items.,Możesz opublikować do 200 pozycji.,
-You have to enable auto re-order in Stock Settings to maintain re-order levels.,"Aby utrzymać poziomy ponownego zamówienia, musisz włączyć automatyczne ponowne zamówienie w Ustawieniach zapasów.",
-You must be a registered supplier to generate e-Way Bill,"Musisz być zarejestrowanym dostawcą, aby wygenerować e-Way Bill",
-You need to login as a Marketplace User before you can add any reviews.,"Musisz się zalogować jako użytkownik portalu, aby móc dodawać recenzje.",
-Your Featured Items,Twoje polecane przedmioty,
-Your Items,Twoje przedmioty,
-Your Profile,Twój profil,
-Your rating:,Twoja ocena:,
-and,i,
-e-Way Bill already exists for this document,e-Way Bill już istnieje dla tego dokumentu,
-woocommerce - {0},woocommerce - {0},
-{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Wykorzystany kupon to {1}. Dozwolona ilość jest wyczerpana,
-{0} Name,Imię {0},
-{0} Operations: {1},{0} Operacje: {1},
-{0} bank transaction(s) created,{0} utworzono transakcje bankowe,
-{0} bank transaction(s) created and {1} errors,{0} utworzono transakcje bankowe i błędy {1},
-{0} can not be greater than {1},{0} nie może być większy niż {1},
-{0} conversations,{0} rozmów,
-{0} is not a company bank account,{0} nie jest firmowym kontem bankowym,
-{0} is not a group node. Please select a group node as parent cost center,{0} nie jest węzłem grupy. Wybierz węzeł grupy jako macierzyste centrum kosztów,
-{0} is not the default supplier for any items.,{0} nie jest domyślnym dostawcą dla żadnych przedmiotów.,
-{0} is required,{0} is wymagany,
-{0}: {1} must be less than {2},{0}: {1} musi być mniejsze niż {2},
-{} is an invalid Attendance Status.,{} to nieprawidłowy status frekwencji.,
-{} is required to generate E-Way Bill JSON,{} jest wymagane do wygenerowania E-Way Bill JSON,
-"Invalid lost reason {0}, please create a new lost reason","Nieprawidłowy utracony powód {0}, utwórz nowy utracony powód",
-Profit This Year,Zysk w tym roku,
-Total Expense,Łączny koszt,
-Total Expense This Year,Całkowity koszt w tym roku,
-Total Income,Całkowity przychód,
-Total Income This Year,Dochód ogółem w tym roku,
-Barcode,kod kreskowy,
-Bold,Pogrubienie,
-Center,Środek,
-Clear,Jasny,
-Comment,Komentarz,
-Comments,Komentarze,
-DocType,DocType,
-Download,Pobieranie,
-Left,Opuścił,
-Link,Połączyć,
-New,Nowy,
-Not Found,Nie znaleziono,
-Print,Wydrukować,
-Reference Name,Nazwa referencyjna,
-Refresh,Odśwież,
-Success,Sukces,
-Time,Czas,
-Value,Wartość,
-Actual,Rzeczywisty,
-Add to Cart,Dodaj do koszyka,
-Days Since Last Order,Dni od ostatniego zamówienia,
-In Stock,W magazynie,
-Loan Amount is mandatory,Kwota pożyczki jest obowiązkowa,
-Mode Of Payment,Rodzaj płatności,
-No students Found,Nie znaleziono studentów,
-Not in Stock,Brak na stanie,
-Please select a Customer,Proszę wybrać klienta,
-Printed On,wydrukowane na,
-Received From,Otrzymane od,
-Sales Person,Sprzedawca,
-To date cannot be before From date,"""Do daty"" nie może być terminem przed ""od daty""",
-Write Off,Odpis,
-{0} Created,{0} utworzone,
-Email Id,Identyfikator E-mail,
-No,Nie,
-Reference Doctype,DocType Odniesienia,
-User Id,Identyfikator użytkownika,
-Yes,tak,
-Actual ,Właściwy,
-Add to cart,Dodaj do koszyka,
-Budget,Budżet,
-Chart of Accounts,Plan kont,
-Customer database.,Baza danych klientów.,
-Days Since Last order,Dni od ostatniego zamówienia,
-Download as JSON,Pobierz jako JSON,
-End date can not be less than start date,"Data zakończenia nie może być wcześniejsza, niż data rozpoczęcia",
-For Default Supplier (Optional),Dla dostawcy domyślnego (opcjonalnie),
-From date cannot be greater than To date,Data od - nie może być późniejsza niż Data do,
-Group by,Grupuj według,
-In stock,W magazynie,
-Item name,Nazwa pozycji,
-Loan amount is mandatory,Kwota pożyczki jest obowiązkowa,
-Minimum Qty,Minimalna ilość,
-More details,Więcej szczegółów,
-Nature of Supplies,Natura dostaw,
-No Items found.,Nie znaleziono żadnych przedmiotów.,
-No employee found,Nie znaleziono pracowników,
-No students found,Nie znaleziono studentów,
-Not in stock,Brak na stanie,
-Not permitted,Nie dozwolone,
-Open Issues ,Otwarte kwestie,
-Open Projects ,Otwarte projekty,
-Open To Do ,Otwarty na uwagi,
-Operation Id,Operacja ID,
-Partially ordered,częściowo Zamówione,
-Please select company first,Najpierw wybierz firmę,
-Please select patient,Wybierz pacjenta,
-Printed On ,Nadrukowany na,
-Projected qty,Prognozowana ilość,
-Sales person,Sprzedawca,
-Serial No {0} Created,Stworzono nr seryjny {0},
-Source Location is required for the Asset {0},Lokalizacja źródła jest wymagana dla zasobu {0},
-Tax Id,Identyfikator podatkowy,
-To Time,Do czasu,
-To date cannot be before from date,To Date nie może być wcześniejsza niż From Date,
-Total Taxable value,Całkowita wartość podlegająca opodatkowaniu,
-Upcoming Calendar Events ,Nadchodzące wydarzenia kalendarzowe,
-Value or Qty,Wartość albo Ilość,
-Variance ,Zmienność,
-Variant of,Wariant,
-Write off,Odpis,
-hours,godziny,
-received from,otrzymane od,
-to,do,
-Cards,Karty,
-Percentage,Odsetek,
-Failed to setup defaults for country {0}. Please contact support@erpnext.com,Nie udało się skonfigurować wartości domyślnych dla kraju {0}. Skontaktuj się z support@erpnext.com,
-Row #{0}: Item {1} is not a Serialized/Batched Item. It cannot have a Serial No/Batch No against it.,Wiersz # {0}: pozycja {1} nie jest przedmiotem serializowanym / partiami. Nie może mieć numeru seryjnego / numeru partii.,
-Please set {0},Ustaw {0},
-Please set {0},Ustaw {0},supplier
-Draft,Wersja robocza,"docstatus,=,0"
-Cancelled,Anulowany,"docstatus,=,2"
-Please setup Instructor Naming System in Education > Education Settings,Skonfiguruj system nazewnictwa instruktorów w sekcji Edukacja&gt; Ustawienia edukacji,
-Please set Naming Series for {0} via Setup > Settings > Naming Series,Ustaw Serie nazw dla {0} poprzez Ustawienia&gt; Ustawienia&gt; Serie nazw,
-UOM Conversion factor ({0} -> {1}) not found for item: {2},Nie znaleziono współczynnika konwersji UOM ({0} -&gt; {1}) dla elementu: {2},
-Item Code > Item Group > Brand,Kod pozycji&gt; Grupa produktów&gt; Marka,
-Customer > Customer Group > Territory,Klient&gt; Grupa klientów&gt; Terytorium,
-Supplier > Supplier Type,Dostawca&gt; Rodzaj dostawcy,
-Please setup Employee Naming System in Human Resource > HR Settings,Skonfiguruj system nazewnictwa pracowników w dziale Zasoby ludzkie&gt; Ustawienia HR,
-Please setup numbering series for Attendance via Setup > Numbering Series,Skonfiguruj serie numeracji dla frekwencji poprzez Ustawienia&gt; Serie numeracji,
-The value of {0} differs between Items {1} and {2},Wartość {0} różni się między elementami {1} i {2},
-Auto Fetch,Automatyczne pobieranie,
-Fetch Serial Numbers based on FIFO,Pobierz numery seryjne na podstawie FIFO,
-"Outward taxable supplies(other than zero rated, nil rated and exempted)","Dostawy podlegające opodatkowaniu zewnętrznemu (inne niż zerowe, zerowe i zwolnione)",
-"To allow different rates, disable the {0} checkbox in {1}.","Aby zezwolić na różne stawki, wyłącz {0} pole wyboru w {1}.",
-Current Odometer Value should be greater than Last Odometer Value {0},Bieżąca wartość drogomierza powinna być większa niż ostatnia wartość drogomierza {0},
-No additional expenses has been added,Nie dodano żadnych dodatkowych kosztów,
-Asset{} {assets_link} created for {},Zasób {} {asset_link} utworzony dla {},
-Row {}: Asset Naming Series is mandatory for the auto creation for item {},Wiersz {}: Seria nazewnictwa zasobów jest wymagana w przypadku automatycznego tworzenia elementu {},
-Assets not created for {0}. You will have to create asset manually.,Zasoby nie zostały utworzone dla {0}. Będziesz musiał utworzyć zasób ręcznie.,
-{0} {1} has accounting entries in currency {2} for company {3}. Please select a receivable or payable account with currency {2}.,{0} {1} ma zapisy księgowe w walucie {2} firmy {3}. Wybierz konto należności lub zobowiązania w walucie {2}.,
-Invalid Account,Nieważne konto,
-Purchase Order Required,Wymagane zamówienia kupna,
-Purchase Receipt Required,Wymagane potwierdzenie zakupu,
-Account Missing,Brak konta,
-Requested,Zamówiony,
-Partially Paid,Częściowo wypłacone,
-Invalid Account Currency,Nieprawidłowa waluta konta,
-"Row {0}: The item {1}, quantity must be positive number","Wiersz {0}: pozycja {1}, ilość musi być liczbą dodatnią",
-"Please set {0} for Batched Item {1}, which is used to set {2} on Submit.","Ustaw {0} dla pozycji wsadowej {1}, która jest używana do ustawiania {2} podczas przesyłania.",
-Expiry Date Mandatory,Data wygaśnięcia jest obowiązkowa,
-Variant Item,Wariant pozycji,
-BOM 1 {0} and BOM 2 {1} should not be same,BOM 1 {0} i BOM 2 {1} nie powinny być takie same,
-Note: Item {0} added multiple times,Uwaga: element {0} został dodany wiele razy,
-YouTube,Youtube,
-Vimeo,Vimeo,
-Publish Date,Data publikacji,
-Duration,Trwanie,
-Advanced Settings,Zaawansowane ustawienia,
-Path,Ścieżka,
-Components,składniki,
-Verified By,Zweryfikowane przez,
-Invalid naming series (. missing) for {0},Nieprawidłowa seria nazw (brak.) Dla {0},
-Filter Based On,Filtruj na podstawie,
-Reqd by date,Wymagane według daty,
-Manufacturer Part Number <b>{0}</b> is invalid,Numer części producenta <b>{0}</b> jest nieprawidłowy,
-Invalid Part Number,Nieprawidłowy numer części,
-Select atleast one Social Media from Share on.,Wybierz co najmniej jeden serwis społecznościowy z Udostępnij na.,
-Invalid Scheduled Time,Nieprawidłowy zaplanowany czas,
-Length Must be less than 280.,Długość musi być mniejsza niż 280.,
-Error while POSTING {0},Błąd podczas WPISYWANIA {0},
-"Session not valid, Do you want to login?","Sesja nieważna, czy chcesz się zalogować?",
-Session Active,Sesja aktywna,
-Session Not Active. Save doc to login.,"Sesja nieaktywna. Zapisz dokument, aby się zalogować.",
-Error! Failed to get request token.,Błąd! Nie udało się uzyskać tokena żądania.,
-Invalid {0} or {1},Nieprawidłowy {0} lub {1},
-Error! Failed to get access token.,Błąd! Nie udało się uzyskać tokena dostępu.,
-Invalid Consumer Key or Consumer Secret Key,Nieprawidłowy klucz klienta lub tajny klucz klienta,
-Your Session will be expire in ,Twoja sesja wygaśnie za,
- days.,dni.,
-Session is expired. Save doc to login.,"Sesja wygasła. Zapisz dokument, aby się zalogować.",
-Error While Uploading Image,Błąd podczas przesyłania obrazu,
-You Didn't have permission to access this API,Nie masz uprawnień dostępu do tego interfejsu API,
-Valid Upto date cannot be before Valid From date,Data Valid Upto nie może być wcześniejsza niż data Valid From,
-Valid From date not in Fiscal Year {0},Data ważności od nie w roku podatkowym {0},
-Valid Upto date not in Fiscal Year {0},Ważna data ważności nie w roku podatkowym {0},
-Group Roll No,Group Roll No,
-Maintain Same Rate Throughout Sales Cycle,Utrzymanie tej samej stawki przez cały cykl sprzedaży,
-"Row {1}: Quantity ({0}) cannot be a fraction. To allow this, disable '{2}' in UOM {3}.","Wiersz {1}: ilość ({0}) nie może być ułamkiem. Aby to umożliwić, wyłącz &#39;{2}&#39; w UOM {3}.",
-Must be Whole Number,Musi być liczbą całkowitą,
-Please setup Razorpay Plan ID,Skonfiguruj identyfikator planu Razorpay,
-Contact Creation Failed,Utworzenie kontaktu nie powiodło się,
-{0} already exists for employee {1} and period {2},{0} już istnieje dla pracownika {1} i okresu {2},
-Leaves Allocated,Liście przydzielone,
-Leaves Expired,Liście wygasły,
-Leave Without Pay does not match with approved {} records,Urlop bez wynagrodzenia nie zgadza się z zatwierdzonymi rekordami {},
-Income Tax Slab not set in Salary Structure Assignment: {0},Podatek dochodowy nie jest ustawiony w przypisaniu struktury wynagrodzenia: {0},
-Income Tax Slab: {0} is disabled,Płyta podatku dochodowego: {0} jest wyłączona,
-Income Tax Slab must be effective on or before Payroll Period Start Date: {0},Płyta podatku dochodowego musi obowiązywać w dniu rozpoczęcia okresu wypłaty wynagrodzenia lub wcześniej: {0},
-No leave record found for employee {0} on {1},Nie znaleziono rekordu urlopu dla pracownika {0} w dniu {1},
-Row {0}: {1} is required in the expenses table to book an expense claim.,"Wiersz {0}: {1} jest wymagany w tabeli wydatków, aby zarezerwować wniosek o zwrot wydatków.",
-Set the default account for the {0} {1},Ustaw domyślne konto dla {0} {1},
-(Half Day),(Połowa dnia),
-Income Tax Slab,Płyta podatku dochodowego,
-Row #{0}: Cannot set amount or formula for Salary Component {1} with Variable Based On Taxable Salary,Wiersz nr {0}: nie można ustawić kwoty lub formuły dla składnika wynagrodzenia {1} ze zmienną opartą na wynagrodzeniu podlegającym opodatkowaniu,
-Row #{}: {} of {} should be {}. Please modify the account or select a different account.,Wiersz nr {}: {} z {} powinien być {}. Zmodyfikuj konto lub wybierz inne konto.,
-Row #{}: Please asign task to a member.,Wiersz nr {}: Przydziel zadanie członkowi.,
-Process Failed,Proces nie powiódł się,
-Tally Migration Error,Błąd migracji Tally,
-Please set Warehouse in Woocommerce Settings,Ustaw Magazyn w Ustawieniach Woocommerce,
-Row {0}: Delivery Warehouse ({1}) and Customer Warehouse ({2}) can not be same,Wiersz {0}: Magazyn dostaw ({1}) i Magazyn klienta ({2}) nie mogą być takie same,
-Row {0}: Due Date in the Payment Terms table cannot be before Posting Date,Wiersz {0}: Termin płatności w tabeli Warunki płatności nie może być wcześniejszy niż data księgowania,
-Cannot find {} for item {}. Please set the same in Item Master or Stock Settings.,Nie można znaleźć {} dla elementu {}. Proszę ustawić to samo w pozycji Główny lub Ustawienia zapasów.,
-Row #{0}: The batch {1} has already expired.,Wiersz nr {0}: partia {1} już wygasła.,
-Start Year and End Year are mandatory,Rok rozpoczęcia i rok zakończenia są obowiązkowe,
-GL Entry,Wejście GL,
-Cannot allocate more than {0} against payment term {1},Nie można przydzielić więcej niż {0} na okres płatności {1},
-The root account {0} must be a group,Konto root {0} musi być grupą,
-Shipping rule not applicable for country {0} in Shipping Address,Reguła dostawy nie dotyczy kraju {0} w adresie dostawy,
-Get Payments from,Otrzymuj płatności od,
-Set Shipping Address or Billing Address,Ustaw adres wysyłki lub adres rozliczeniowy,
-Consultation Setup,Konfiguracja konsultacji,
-Fee Validity,Ważność opłaty,
-Laboratory Setup,Przygotowanie laboratorium,
-Dosage Form,Forma dawkowania,
-Records and History,Zapisy i historia,
-Patient Medical Record,Medyczny dokument medyczny pacjenta,
-Rehabilitation,Rehabilitacja,
-Exercise Type,Typ ćwiczenia,
-Exercise Difficulty Level,Poziom trudności ćwiczeń,
-Therapy Type,Rodzaj terapii,
-Therapy Plan,Plan terapii,
-Therapy Session,Sesja terapeutyczna,
-Motor Assessment Scale,Skala Oceny Motorycznej,
-[Important] [ERPNext] Auto Reorder Errors,[Ważne] [ERPNext] Błędy automatycznego ponownego zamawiania,
-"Regards,","Pozdrowienia,",
-The following {0} were created: {1},Utworzono następujące {0}: {1},
-Work Orders,Zlecenia pracy,
-The {0} {1} created sucessfully,{0} {1} został pomyślnie utworzony,
-Work Order cannot be created for following reason: <br> {0},Nie można utworzyć zlecenia pracy z następującego powodu:<br> {0},
-Add items in the Item Locations table,Dodaj pozycje w tabeli Lokalizacje pozycji,
-Update Current Stock,Zaktualizuj aktualne zapasy,
-"{0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Zachowaj próbkę na podstawie partii. Zaznacz opcję Ma nr partii, aby zachować próbkę elementu",
-Empty,Pusty,
-Currently no stock available in any warehouse,Obecnie nie ma zapasów w żadnym magazynie,
-BOM Qty,BOM Qty,
-Time logs are required for {0} {1},Dzienniki czasu są wymagane dla {0} {1},
-Total Completed Qty,Całkowita ukończona ilość,
-Qty to Manufacture,Ilość do wyprodukowania,
-Repay From Salary can be selected only for term loans,Spłata z wynagrodzenia może być wybrana tylko dla pożyczek terminowych,
-No valid Loan Security Price found for {0},Nie znaleziono prawidłowej ceny zabezpieczenia pożyczki dla {0},
-Loan Account and Payment Account cannot be same,Rachunek pożyczki i rachunek płatniczy nie mogą być takie same,
-Loan Security Pledge can only be created for secured loans,Zabezpieczenie pożyczki można ustanowić tylko w przypadku pożyczek zabezpieczonych,
-Social Media Campaigns,Kampanie w mediach społecznościowych,
-From Date can not be greater than To Date,Data początkowa nie może być większa niż data początkowa,
-Please set a Customer linked to the Patient,Ustaw klienta powiązanego z pacjentem,
-Customer Not Found,Nie znaleziono klienta,
-Please Configure Clinical Procedure Consumable Item in ,Skonfiguruj materiał eksploatacyjny do procedury klinicznej w,
-Missing Configuration,Brak konfiguracji,
-Out Patient Consulting Charge Item,Out Patient Consulting Charge Item,
-Inpatient Visit Charge Item,Opłata za wizyta stacjonarna,
-OP Consulting Charge,OP Consulting Charge,
-Inpatient Visit Charge,Opłata za wizytę stacjonarną,
-Appointment Status,Status spotkania,
-Test: ,Test:,
-Collection Details: ,Szczegóły kolekcji:,
-{0} out of {1},{0} z {1},
-Select Therapy Type,Wybierz typ terapii,
-{0} sessions completed,Ukończono {0} sesje,
-{0} session completed,Sesja {0} zakończona,
- out of {0},z {0},
-Therapy Sessions,Sesje terapeutyczne,
-Add Exercise Step,Dodaj krok ćwiczenia,
-Edit Exercise Step,Edytuj krok ćwiczenia,
-Patient Appointments,Spotkania pacjentów,
-Item with Item Code {0} already exists,Przedmiot o kodzie pozycji {0} już istnieje,
-Registration Fee cannot be negative or zero,Opłata rejestracyjna nie może być ujemna ani zerowa,
-Configure a service Item for {0},Skonfiguruj usługę dla {0},
-Temperature: ,Temperatura:,
-Pulse: ,Puls:,
-Respiratory Rate: ,Częstość oddechów:,
-BP: ,BP:,
-BMI: ,BMI:,
-Note: ,Uwaga:,
-Check Availability,Sprawdź dostępność,
-Please select Patient first,Najpierw wybierz pacjenta,
-Please select a Mode of Payment first,Najpierw wybierz sposób płatności,
-Please set the Paid Amount first,Najpierw ustaw Kwotę do zapłaty,
-Not Therapies Prescribed,Nie przepisane terapie,
-There are no Therapies prescribed for Patient {0},Nie ma przepisanych terapii dla pacjenta {0},
-Appointment date and Healthcare Practitioner are Mandatory,Data wizyty i lekarz są obowiązkowe,
-No Prescribed Procedures found for the selected Patient,Nie znaleziono przepisanych procedur dla wybranego pacjenta,
-Please select a Patient first,Najpierw wybierz pacjenta,
-There are no procedure prescribed for ,Nie ma określonej procedury,
-Prescribed Therapies,Terapie przepisane,
-Appointment overlaps with ,Termin pokrywa się z,
-{0} has appointment scheduled with {1} at {2} having {3} minute(s) duration.,{0} ma zaplanowane spotkanie z {1} na {2} trwające {3} minut (y).,
-Appointments Overlapping,Nakładające się terminy,
-Consulting Charges: {0},Opłaty za konsultacje: {0},
-Appointment Cancelled. Please review and cancel the invoice {0},Spotkanie odwołane. Sprawdź i anuluj fakturę {0},
-Appointment Cancelled.,Spotkanie odwołane.,
-Fee Validity {0} updated.,Zaktualizowano ważność opłaty {0}.,
-Practitioner Schedule Not Found,Nie znaleziono harmonogramu lekarza,
-{0} is on a Half day Leave on {1},{0} korzysta z urlopu półdniowego dnia {1},
-{0} is on Leave on {1},{0} jest na urlopie na {1},
-{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner,{0} nie ma harmonogramu lekarzy. Dodaj go do lekarza,
-Healthcare Service Units,Jednostki opieki zdrowotnej,
-Complete and Consume,Uzupełnij i zużyj,
-Complete {0} and Consume Stock?,Uzupełnić {0} i zużyć zapasy?,
-Complete {0}?,Ukończono {0}?,
-Stock quantity to start the Procedure is not available in the Warehouse {0}. Do you want to record a Stock Entry?,Ilość zapasów potrzebna do rozpoczęcia procedury nie jest dostępna w magazynie {0}. Czy chcesz zarejestrować wejście na giełdę?,
-{0} as on {1},{0} jak w dniu {1},
-Clinical Procedure ({0}):,Procedura kliniczna ({0}):,
-Please set Customer in Patient {0},Ustaw klienta jako pacjenta {0},
-Item {0} is not active,Przedmiot {0} nie jest aktywny,
-Therapy Plan {0} created successfully.,Plan terapii {0} został utworzony pomyślnie.,
-Symptoms: ,Objawy:,
-No Symptoms,Brak objawów,
-Diagnosis: ,Diagnoza:,
-No Diagnosis,Brak diagnozy,
-Drug(s) Prescribed.,Leki przepisane.,
-Test(s) Prescribed.,Test (y) przepisane.,
-Procedure(s) Prescribed.,Procedura (-y) zalecana (-e).,
-Counts Completed: {0},Liczenie zakończone: {0},
-Patient Assessment,Ocena stanu pacjenta,
-Assessments,Oceny,
-Heads (or groups) against which Accounting Entries are made and balances are maintained.,"Heads (lub grupy), przeciwko którym zapisy księgowe są i sald są utrzymywane.",
-Account Name,Nazwa konta,
-Inter Company Account,Konto firmowe Inter,
-Parent Account,Nadrzędne konto,
-Setting Account Type helps in selecting this Account in transactions.,Ustawienie Typu Konta pomaga w wyborze tego konta w transakcji.,
-Chargeable,Odpowedni do pobierania opłaty.,
-Rate at which this tax is applied,Stawka przy użyciu której ten podatek jest aplikowany,
-Frozen,Zamrożony,
-"If the account is frozen, entries are allowed to restricted users.","Jeśli konto jest zamrożone, zapisy mogą wykonywać tylko wyznaczone osoby.",
-Balance must be,Bilans powinien wynosić,
-Lft,Lft,
-Rgt,Rgt,
-Old Parent,Stary obiekt nadrzędny,
-Include in gross,Uwzględnij w brutto,
-Auditor,Audytor,
-Accounting Dimension,Wymiar księgowy,
-Dimension Name,Nazwa wymiaru,
-Dimension Defaults,Domyślne wymiary,
-Accounting Dimension Detail,Szczegóły wymiaru księgowości,
-Default Dimension,Domyślny wymiar,
-Mandatory For Balance Sheet,Obowiązkowe dla bilansu,
-Mandatory For Profit and Loss Account,Obowiązkowe dla rachunku zysków i strat,
-Accounting Period,Okres Księgowy,
-Period Name,Nazwa okresu,
-Closed Documents,Zamknięte dokumenty,
-Accounts Settings,Ustawienia Kont,
-Settings for Accounts,Ustawienia Konta,
-Make Accounting Entry For Every Stock Movement,Tworzenie Zapisów Księgowych dla każdej zmiany stanu Magazynu,
-Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Użytkownicy z tą rolą mogą ustawiać zamrożone konta i tworzyć / modyfikować wpisy księgowe dla zamrożonych kont,
-Determine Address Tax Category From,Określ kategorię podatku adresowego od,
-Over Billing Allowance (%),Over Billing Allowance (%),
-Credit Controller,,
-Check Supplier Invoice Number Uniqueness,"Sprawdź, czy numer faktury dostawcy jest unikalny",
-Make Payment via Journal Entry,Wykonywanie płatności za pośrednictwem Zapisów Księgowych dziennika,
-Unlink Payment on Cancellation of Invoice,Odłączanie Przedpłata na Anulowanie faktury,
-Book Asset Depreciation Entry Automatically,Automatycznie wprowadź wartość księgowania depozytu księgowego aktywów,
-Automatically Add Taxes and Charges from Item Tax Template,Automatycznie dodawaj podatki i opłaty z szablonu podatku od towarów,
-Automatically Fetch Payment Terms,Automatycznie pobierz warunki płatności,
-Show Payment Schedule in Print,Pokaż harmonogram płatności w druku,
-Currency Exchange Settings,Ustawienia wymiany walut,
-Allow Stale Exchange Rates,Zezwalaj na Stałe Kursy walut,
-Stale Days,Stale Dni,
-Report Settings,Ustawienia raportu,
-Use Custom Cash Flow Format,Użyj niestandardowego formatu przepływu środków pieniężnych,
-Allowed To Transact With,Zezwolono na zawieranie transakcji przy użyciu,
-SWIFT number,Numer swift,
-Branch Code,Kod oddziału,
-Address and Contact,Adres i Kontakt,
-Address HTML,Adres HTML,
-Contact HTML,HTML kontaktu,
-Data Import Configuration,Konfiguracja importu danych,
-Bank Transaction Mapping,Mapowanie transakcji bankowych,
-Plaid Access Token,Token dostępu do kratki,
-Company Account,Konto firmowe,
-Account Subtype,Podtyp konta,
-Is Default Account,Jest kontem domyślnym,
-Is Company Account,Jest kontem firmowym,
-Party Details,Strona Szczegóły,
-Account Details,Szczegóły konta,
-IBAN,IBAN,
-Bank Account No,Nr konta bankowego,
-Integration Details,Szczegóły integracji,
-Integration ID,Identyfikator integracji,
-Last Integration Date,Ostatnia data integracji,
-Change this date manually to setup the next synchronization start date,"Zmień tę datę ręcznie, aby ustawić następną datę rozpoczęcia synchronizacji",
-Mask,Maska,
-Bank Account Subtype,Podtyp konta bankowego,
-Bank Account Type,Typ konta bankowego,
-Bank Guarantee,Gwarancja bankowa,
-Bank Guarantee Type,Rodzaj gwarancji bankowej,
-Receiving,Odbieranie,
-Providing,Że,
-Reference Document Name,Nazwa dokumentu referencyjnego,
-Validity in Days,Ważność w dniach,
-Bank Account Info,Informacje o koncie bankowym,
-Clauses and Conditions,Klauzule i warunki,
-Other Details,Inne szczegóły,
-Bank Guarantee Number,Numer Gwarancji Bankowej,
-Name of Beneficiary,Imię beneficjenta,
-Margin Money,Marża pieniężna,
-Charges Incurred,Naliczone opłaty,
-Fixed Deposit Number,Naprawiono numer depozytu,
-Account Currency,Waluta konta,
-Select the Bank Account to reconcile.,Wybierz konto bankowe do uzgodnienia.,
-Include Reconciled Entries,Dołącz uzgodnione wpisy,
-Get Payment Entries,Uzyskaj Wpisy płatności,
-Payment Entries,Wpisy płatności,
-Update Clearance Date,Aktualizacja daty rozliczenia,
-Bank Reconciliation Detail,Uzgodnienia z wyciągiem bankowym - szczegóły,
-Cheque Number,Numer czeku,
-Cheque Date,Data czeku,
-Statement Header Mapping,Mapowanie nagłówków instrukcji,
-Statement Headers,Nagłówki instrukcji,
-Transaction Data Mapping,Mapowanie danych transakcji,
-Mapped Items,Zmapowane elementy,
-Bank Statement Settings Item,Ustawienia wyciągu bankowego Pozycja,
-Mapped Header,Mapowany nagłówek,
-Bank Header,Nagłówek banku,
-Bank Statement Transaction Entry,Wpis transakcji z wyciągu bankowego,
-Bank Transaction Entries,Wpisy transakcji bankowych,
-New Transactions,Nowe transakcje,
-Match Transaction to Invoices,Dopasuj transakcję do faktur,
-Create New Payment/Journal Entry,Utwórz nową pozycję płatności / księgowania,
-Submit/Reconcile Payments,Wpisz/Uzgodnij płatności,
-Matching Invoices,Dopasowanie faktur,
-Payment Invoice Items,Faktury z płatności,
-Reconciled Transactions,Uzgodnione transakcje,
-Bank Statement Transaction Invoice Item,Wyciąg z rachunku bankowego,
-Payment Description,Opis płatności,
-Invoice Date,Data faktury,
-invoice,faktura,
-Bank Statement Transaction Payment Item,Wyciąg z transakcji bankowych,
-outstanding_amount,pozostająca kwota,
-Payment Reference,Referencje płatności,
-Bank Statement Transaction Settings Item,Ustawienia transakcji bankowych Pozycja,
-Bank Data,Dane bankowe,
-Mapped Data Type,Zmapowany typ danych,
-Mapped Data,Zmapowane dane,
-Bank Transaction,Transakcja bankowa,
-ACC-BTN-.YYYY.-,ACC-BTN-.YYYY.-,
-Transaction ID,Identyfikator transakcji,
-Unallocated Amount,Kwota nieprzydzielone,
-Field in Bank Transaction,Pole w transakcji bankowej,
-Column in Bank File,Kolumna w pliku banku,
-Bank Transaction Payments,Płatności transakcji bankowych,
-Control Action,Działanie kontrolne,
-Applicable on Material Request,Obowiązuje na wniosek materiałowy,
-Action if Annual Budget Exceeded on MR,"Działanie, jeśli budżet roczny przekroczy MR",
-Warn,Ostrzeż,
-Ignore,Ignoruj,
-Action if Accumulated Monthly Budget Exceeded on MR,"Działanie, jeżeli skumulowany budżet miesięczny przekroczył MR",
-Applicable on Purchase Order,Obowiązuje w przypadku zamówienia zakupu,
-Action if Annual Budget Exceeded on PO,"Działanie, jeśli budżet roczny został przekroczony dla zamówienia",
-Action if Accumulated Monthly Budget Exceeded on PO,"Działanie, jeśli skumulowany miesięczny budżet został przekroczony dla zamówienia",
-Applicable on booking actual expenses,Obowiązuje przy rezerwacji rzeczywistych wydatków,
-Action if Annual Budget Exceeded on Actual,"Działanie, jeśli budżet roczny przekroczyłby rzeczywisty",
-Action if Accumulated Monthly Budget Exceeded on Actual,"Działanie, jeżeli skumulowany budżet miesięczny przekroczył rzeczywisty",
-Budget Accounts,Rachunki ekonomiczne,
-Budget Account,Budżet Konta,
-Budget Amount,budżet Kwota,
-C-Form,,
-ACC-CF-.YYYY.-,ACC-CF-.RRRR.-,
-C-Form No,,
-Received Date,Data Otrzymania,
-Quarter,Kwartał,
-I,ja,
-II,II,
-III,III,
-IV,IV,
-C-Form Invoice Detail,,
-Invoice No,Nr faktury,
-Cash Flow Mapper,Mapper przepływu gotówki,
-Section Name,Nazwa sekcji,
-Section Header,Nagłówek sekcji,
-Section Leader,Kierownik sekcji,
-e.g Adjustments for:,np. korekty dla:,
-Section Subtotal,Podsuma sekcji,
-Section Footer,Sekcja stopki,
-Position,Pozycja,
-Cash Flow Mapping,Mapowanie przepływów pieniężnych,
-Select Maximum Of 1,Wybierz Maksimum 1,
-Is Finance Cost,Koszt finansowy,
-Is Working Capital,Jest kapitałem obrotowym,
-Is Finance Cost Adjustment,Czy korekta kosztów finansowych,
-Is Income Tax Liability,Jest odpowiedzialnością z tytułu podatku dochodowego,
-Is Income Tax Expense,Jest kosztem podatku dochodowego,
-Cash Flow Mapping Accounts,Konta mapowania przepływów pieniężnych,
-account,Konto,
-Cash Flow Mapping Template,Szablon mapowania przepływów pieniężnych,
-Cash Flow Mapping Template Details,Szczegóły szablonu mapowania przepływu gotówki,
-POS-CLO-,POS-CLO-,
-Custody,Opieka,
-Net Amount,Kwota netto,
-Cashier Closing Payments,Kasjer Zamykanie płatności,
-Chart of Accounts Importer,Importer planu kont,
-Import Chart of Accounts from a csv file,Importuj plan kont z pliku csv,
-Attach custom Chart of Accounts file,Dołącz niestandardowy plik planu kont,
-Chart Preview,Podgląd wykresu,
-Chart Tree,Drzewo wykresów,
-Cheque Print Template,Sprawdź Szablon druku,
-Has Print Format,Ma format wydruku,
-Primary Settings,Ustawienia podstawowe,
-Cheque Size,Czek Rozmiar,
-Regular,Regularny,
-Starting position from top edge,stanowisko od górnej krawędzi Zaczynając,
-Cheque Width,Czek Szerokość,
-Cheque Height,Czek Wysokość,
-Scanned Cheque,zeskanowanych Czek,
-Is Account Payable,Czy Account Payable,
-Distance from top edge,Odległość od górnej krawędzi,
-Distance from left edge,Odległość od lewej krawędzi,
-Message to show,Wiadomość pokazać,
-Date Settings,Data Ustawienia,
-Starting location from left edge,Zaczynając od lewej krawędzi lokalizację,
-Payer Settings,Ustawienia płatnik,
-Width of amount in word,Szerokość kwoty w słowie,
-Line spacing for amount in words,Odstępy między wierszami dla kwoty w słowach,
-Amount In Figure,Kwota Na rysunku,
-Signatory Position,Sygnatariusz Pozycja,
-Closed Document,Zamknięty dokument,
-Track separate Income and Expense for product verticals or divisions.,Śledź oddzielnie przychody i koszty dla branż produktowych lub oddziałów.,
-Cost Center Name,Nazwa Centrum Kosztów,
-Parent Cost Center,Nadrzędny dział kalkulacji kosztów,
-lft,lft,
-rgt,rgt,
-Coupon Code,Kod kuponu,
-Coupon Name,Nazwa kuponu,
-"e.g. ""Summer Holiday 2019 Offer 20""",np. „Oferta na wakacje 2019 r. 20”,
-Coupon Type,Rodzaj kuponu,
-Promotional,Promocyjny,
-Gift Card,Karta podarunkowa,
-unique e.g. SAVE20  To be used to get discount,unikatowy np. SAVE20 Do wykorzystania w celu uzyskania rabatu,
-Validity and Usage,Ważność i użycie,
-Valid From,Ważne od,
-Valid Upto,Valid Upto,
-Maximum Use,Maksymalne wykorzystanie,
-Used,Używany,
-Coupon Description,Opis kuponu,
-Discounted Invoice,Zniżka na fakturze,
-Debit to,Obciąż do,
-Exchange Rate Revaluation,Przeszacowanie kursu wymiany,
-Get Entries,Uzyskaj wpisy,
-Exchange Rate Revaluation Account,Rachunek przeszacowania kursu wymiany,
-Total Gain/Loss,Całkowity wzrost / strata,
-Balance In Account Currency,Waluta konta w walucie,
-Current Exchange Rate,Aktualny kurs wymiany,
-Balance In Base Currency,Saldo w walucie podstawowej,
-New Exchange Rate,Nowy kurs wymiany,
-New Balance In Base Currency,Nowe saldo w walucie podstawowej,
-Gain/Loss,Zysk / strata,
-**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Rok finansowy** reprezentuje rok finansowy. Wszystkie zapisy księgowe oraz inne znaczące transakcje są śledzone przed ** roku podatkowego **.,
-Year Name,Nazwa roku,
-"For e.g. 2012, 2012-13","np. 2012, 2012-13",
-Year Start Date,Data początku roku,
-Year End Date,Data końca roku,
-Companies,Firmy,
-Auto Created,Automatycznie utworzone,
-Stock User,Użytkownik magazynu,
-Fiscal Year Company,Rok podatkowy firmy,
-Debit Amount,Kwota Debit,
-Credit Amount,Kwota kredytu,
-Debit Amount in Account Currency,Kwota debetową w walucie rachunku,
-Credit Amount in Account Currency,Kwota kredytu w walucie rachunku,
-Voucher Detail No,Nr Szczegółu Bonu,
-Is Opening,Otwiera się,
-Is Advance,Zaawansowany proces,
-To Rename,Aby zmienić nazwę,
-GST Account,Konto GST,
-CGST Account,Konto CGST,
-SGST Account,Konto SGST,
-IGST Account,Konto IGST,
-CESS Account,Konto CESS,
-Loan Start Date,Data rozpoczęcia pożyczki,
-Loan Period (Days),Okres pożyczki (dni),
-Loan End Date,Data zakończenia pożyczki,
-Bank Charges,Opłaty bankowe,
-Short Term Loan Account,Konto pożyczki krótkoterminowej,
-Bank Charges Account,Rachunek opłat bankowych,
-Accounts Receivable Credit Account,Rachunek kredytowy należności,
-Accounts Receivable Discounted Account,Konto z rabatem należności,
-Accounts Receivable Unpaid Account,Niezapłacone konto należności,
-Item Tax Template,Szablon podatku od towarów,
-Tax Rates,Wysokość podatków,
-Item Tax Template Detail,Szczegóły szablonu podatku od towarów,
-Entry Type,Rodzaj wpisu,
-Inter Company Journal Entry,Dziennik firmy Inter Company,
-Bank Entry,Operacja bankowa,
-Cash Entry,Wpis gotówkowy,
-Credit Card Entry,Karta kredytowa,
-Contra Entry,Odpis aktualizujący,
-Excise Entry,Akcyza Wejścia,
-Write Off Entry,Odpis,
-Opening Entry,Wpis początkowy,
-ACC-JV-.YYYY.-,ACC-JV-.RRRR.-,
-Accounting Entries,Zapisy księgowe,
-Total Debit,Całkowita kwota debetu,
-Total Credit,Całkowita kwota kredytu,
-Difference (Dr - Cr),Różnica (Dr - Cr),
-Make Difference Entry,Wprowadź różnicę,
-Total Amount Currency,Suma Waluta Kwota,
-Total Amount in Words,Wartość całkowita słownie,
-Remark,Uwaga,
-Paid Loan,Płatna pożyczka,
-Inter Company Journal Entry Reference,Wpis w dzienniku firmy Inter Company,
-Write Off Based On,Odpis bazowano na,
-Get Outstanding Invoices,Uzyskaj zaległą fakturę,
-Write Off Amount,Kwota odpisu,
-Printing Settings,Ustawienia drukowania,
-Pay To / Recd From,Zapłać / Rachunek od,
-Payment Order,Zlecenie płatnicze,
-Subscription Section,Sekcja subskrypcji,
-Journal Entry Account,Konto zapisu,
-Account Balance,Bilans konta,
-Party Balance,Bilans Grupy,
-Accounting Dimensions,Wymiary księgowe,
-If Income or Expense,Jeśli przychód lub koszt,
-Exchange Rate,Kurs wymiany,
-Debit in Company Currency,Debet w firmie Waluta,
-Credit in Company Currency,Kredyt w walucie Spółki,
-Payroll Entry,Wpis o płace,
-Employee Advance,Advance pracownika,
-Reference Due Date,Referencyjny termin płatności,
-Loyalty Program Tier,Poziom programu lojalnościowego,
-Redeem Against,Zrealizuj przeciw,
-Expiry Date,Data ważności,
-Loyalty Point Entry Redemption,Punkt wejścia do punktu lojalnościowego,
-Redemption Date,Data wykupu,
-Redeemed Points,Wykorzystane punkty,
-Loyalty Program Name,Nazwa programu lojalnościowego,
-Loyalty Program Type,Typ programu lojalnościowego,
-Single Tier Program,Program dla jednego poziomu,
-Multiple Tier Program,Program wielopoziomowy,
-Customer Territory,Terytorium klienta,
-Auto Opt In (For all customers),Automatyczne optowanie (dla wszystkich klientów),
-Collection Tier,Poziom kolekcji,
-Collection Rules,Zasady zbierania,
-Redemption,Odkupienie,
-Conversion Factor,Współczynnik konwersji,
-1 Loyalty Points = How much base currency?,1 punkty lojalnościowe = ile waluty bazowej?,
-Expiry Duration (in days),Okres ważności (w dniach),
-Help Section,Sekcja pomocy,
-Loyalty Program Help,Pomoc programu lojalnościowego,
-Loyalty Program Collection,Kolekcja programu lojalnościowego,
-Tier Name,Nazwa warstwy,
-Minimum Total Spent,Minimalna łączna kwota wydana,
-Collection Factor (=1 LP),Współczynnik zbierania (= 1 LP),
-For how much spent = 1 Loyalty Point,Za ile zużytego = 1 punkt lojalnościowy,
-Mode of Payment Account,Konto księgowe dla tego rodzaju płatności,
-Default Account,Domyślne konto,
-Default account will be automatically updated in POS Invoice when this mode is selected.,Domyślne konto zostanie automatycznie zaktualizowane na fakturze POS po wybraniu tego trybu.,
-**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"** Miesięczna Dystrybucja ** pomaga rozłożyć budżet/cel w miesiącach, jeśli masz okresowość w firmie.",
-Distribution Name,Nazwa Dystrybucji,
-Name of the Monthly Distribution,Nazwa dystrybucji miesięcznej,
-Monthly Distribution Percentages,Miesięczne Procenty Dystrybucja,
-Monthly Distribution Percentage,Miesięczny rozkład procentowy,
-Percentage Allocation,Przydział Procentowy,
-Create Missing Party,Utwórz brakującą imprezę,
-Create missing customer or supplier.,Utwórz brakującego klienta lub dostawcę.,
-Opening Invoice Creation Tool Item,Otwieranie narzędzia tworzenia faktury,
-Temporary Opening Account,Tymczasowe konto otwarcia,
-Party Account,Konto Grupy,
-Type of Payment,Rodzaj płatności,
-ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-,
-Receive,Odbierać,
-Internal Transfer,Transfer wewnętrzny,
-Payment Order Status,Status zlecenia płatniczego,
-Payment Ordered,Płatność zamówiona,
-Payment From / To,Płatność Od / Do,
-Company Bank Account,Konto bankowe firmy,
-Party Bank Account,Party Bank Account,
-Account Paid From,Konto do płatności,
-Account Paid To,Konto do zapłaty,
-Paid Amount (Company Currency),Zapłacona kwota (waluta firmy),
-Received Amount,Kwota otrzymana,
-Received Amount (Company Currency),Otrzymaną kwotą (Spółka waluty),
-Get Outstanding Invoice,Uzyskaj wyjątkową fakturę,
-Payment References,Odniesienia płatności,
-Writeoff,Writeoff,
-Total Allocated Amount,Łączna kwota przyznanego wsparcia,
-Total Allocated Amount (Company Currency),Łączna kwota przyznanego wsparcia (Spółka waluty),
-Set Exchange Gain / Loss,Ustaw Exchange Zysk / strata,
-Difference Amount (Company Currency),Różnica Kwota (waluta firmy),
-Write Off Difference Amount,Różnica Kwota odpisuje,
-Deductions or Loss,Odliczenia lub strata,
-Payment Deductions or Loss,Odliczenia płatności lub strata,
-Cheque/Reference Date,Czek / Reference Data,
-Payment Entry Deduction,Płatność Wejście Odliczenie,
-Payment Entry Reference,Wejście Płatność referencyjny,
-Allocated,Przydzielone,
-Payment Gateway Account,Płatność konto Brama,
-Payment Account,Konto Płatność,
-Default Payment Request Message,Domyślnie Płatność Zapytanie Wiadomość,
-PMO-,PMO-,
-Payment Order Type,Typ zlecenia płatniczego,
-Payment Order Reference,Referencje dotyczące płatności,
-Bank Account Details,Szczegóły konta bankowego,
-Payment Reconciliation,Uzgodnienie płatności,
-Receivable / Payable Account,Konto Należności / Zobowiązań,
-Bank / Cash Account,Rachunek Bankowy/Kasowy,
-From Invoice Date,Od daty faktury,
-To Invoice Date,Aby Data faktury,
-Minimum Invoice Amount,Minimalna kwota faktury,
-Maximum Invoice Amount,Maksymalna kwota faktury,
-System will fetch all the entries if limit value is zero.,"System pobierze wszystkie wpisy, jeśli wartość graniczna wynosi zero.",
-Get Unreconciled Entries,Pobierz Wpisy nieuzgodnione,
-Unreconciled Payment Details,Szczegóły płatności nieuzgodnione,
-Invoice/Journal Entry Details,Szczegóły Faktury / Wpisu dziennika,
-Payment Reconciliation Invoice,Płatność Wyrównawcza Faktury,
-Invoice Number,Numer faktury,
-Payment Reconciliation Payment,Płatność Wyrównawcza Płatności,
-Reference Row,Odniesienie Row,
-Allocated amount,Przyznana kwota,
-Payment Request Type,Typ żądania płatności,
-Outward,Zewnętrzny,
-Inward,Wewnętrzny,
-ACC-PRQ-.YYYY.-,ACC-PRQ-.RRRR.-,
-Transaction Details,szczegóły transakcji,
-Amount in customer's currency,Kwota w walucie klienta,
-Is a Subscription,Jest subskrypcją,
-Transaction Currency,walucie transakcji,
-Subscription Plans,Plany subskrypcji,
-SWIFT Number,Numer SWIFT,
-Recipient Message And Payment Details,Odbiorca wiadomości i szczegóły płatności,
-Make Sales Invoice,Nowa faktura sprzedaży,
-Mute Email,Wyciszenie email,
-payment_url,payment_url,
-Payment Gateway Details,Payment Gateway Szczegóły,
-Payment Schedule,Harmonogram płatności,
-Invoice Portion,Fragment faktury,
-Payment Amount,Kwota płatności,
-Payment Term Name,Nazwa terminu płatności,
-Due Date Based On,Termin wykonania oparty na,
-Day(s) after invoice date,Dzień (dni) po dacie faktury,
-Day(s) after the end of the invoice month,Dzień (dni) po zakończeniu miesiąca faktury,
-Month(s) after the end of the invoice month,Miesiąc (y) po zakończeniu miesiąca faktury,
-Credit Days,,
-Credit Months,Miesiące kredytowe,
-Allocate Payment Based On Payment Terms,Przydziel płatność na podstawie warunków płatności,
-"If this checkbox is checked, paid amount will be splitted and allocated as per the amounts in payment schedule against each payment term","Jeśli to pole wyboru jest zaznaczone, zapłacona kwota zostanie podzielona i przydzielona zgodnie z kwotami w harmonogramie płatności dla każdego terminu płatności",
-Payment Terms Template Detail,Warunki płatności Szczegóły szablonu,
-Closing Fiscal Year,Zamknięcie roku fiskalnego,
-Closing Account Head,,
-"The account head under Liability or Equity, in which Profit/Loss will be booked","Głowica konto ramach odpowiedzialności lub kapitałowe, w których zysk / strata będzie zarezerwowane",
-POS Customer Group,POS Grupa klientów,
-POS Field,Pole POS,
-POS Item Group,POS Pozycja Grupy,
-Company Address,adres spółki,
-Update Stock,Aktualizuj Stan,
-Ignore Pricing Rule,Ignoruj zasadę ustalania cen,
-Applicable for Users,Dotyczy użytkowników,
-Sales Invoice Payment,Faktura sprzedaży Płatność,
-Item Groups,Pozycja Grupy,
-Only show Items from these Item Groups,Pokazuj tylko przedmioty z tych grup przedmiotów,
-Customer Groups,Grupy klientów,
-Only show Customer of these Customer Groups,Pokazuj tylko klientów tych grup klientów,
-Write Off Account,Konto Odpisu,
-Write Off Cost Center,Centrum Kosztów Odpisu,
-Account for Change Amount,Konto dla zmiany kwoty,
-Taxes and Charges,Podatki i opłaty,
-Apply Discount On,Zastosuj RABAT,
-POS Profile User,Użytkownik profilu POS,
-Apply On,Zastosuj Na,
-Price or Product Discount,Rabat na cenę lub produkt,
-Apply Rule On Item Code,Zastosuj regułę do kodu towaru,
-Apply Rule On Item Group,Zastosuj regułę dla grupy pozycji,
-Apply Rule On Brand,Zastosuj regułę do marki,
-Mixed Conditions,Warunki mieszane,
-Conditions will be applied on all the selected items combined. ,Warunki zostaną zastosowane do wszystkich wybranych elementów łącznie.,
-Is Cumulative,Jest kumulatywny,
-Coupon Code Based,Na podstawie kodu kuponu,
-Discount on Other Item,Rabat na inny przedmiot,
-Apply Rule On Other,Zastosuj regułę do innych,
-Party Information,Informacje o imprezie,
-Quantity and Amount,Ilość i kwota,
-Min Qty,Min. ilość,
-Max Qty,Maks. Ilość,
-Min Amt,Min Amt,
-Max Amt,Max Amt,
-Period Settings,Ustawienia okresu,
-Margin,,
-Margin Type,margines Rodzaj,
-Margin Rate or Amount,Margines szybkości lub wielkości,
-Price Discount Scheme,System rabatów cenowych,
-Rate or Discount,Stawka lub zniżka,
-Discount Percentage,Procent zniżki,
-Discount Amount,Wartość zniżki,
-For Price List,Dla Listy Cen,
-Product Discount Scheme,Program rabatów na produkty,
-Same Item,Ten sam przedmiot,
-Free Item,Bezpłatny przedmiot,
-Threshold for Suggestion,Próg dla sugestii,
-System will notify to increase or decrease quantity or amount ,System powiadomi o zwiększeniu lub zmniejszeniu ilości lub ilości,
-"Higher the number, higher the priority","Im wyższa liczba, wyższy priorytet",
-Apply Multiple Pricing Rules,Zastosuj wiele zasad ustalania cen,
-Apply Discount on Rate,Zastosuj zniżkę na stawkę,
-Validate Applied Rule,Sprawdź poprawność zastosowanej reguły,
-Rule Description,Opis reguły,
-Pricing Rule Help,Pomoc dotycząca ustalania cen,
-Promotional Scheme Id,Program promocyjny Id,
-Promotional Scheme,Program promocyjny,
-Pricing Rule Brand,Zasady ustalania ceny marki,
-Pricing Rule Detail,Szczegóły reguły cenowej,
-Child Docname,Nazwa dziecka,
-Rule Applied,Stosowana reguła,
-Pricing Rule Item Code,Kod pozycji reguły cenowej,
-Pricing Rule Item Group,Grupa pozycji Reguły cenowe,
-Price Discount Slabs,Płyty z rabatem cenowym,
-Promotional Scheme Price Discount,Zniżka cenowa programu promocyjnego,
-Product Discount Slabs,Płyty z rabatem na produkty,
-Promotional Scheme Product Discount,Rabat na program promocyjny,
-Min Amount,Min. Kwota,
-Max Amount,Maksymalna kwota,
-Discount Type,Typ rabatu,
-ACC-PINV-.YYYY.-,ACC-PINV-.RRRR.-,
-Tax Withholding Category,Kategoria odwrotnego obciążenia,
-Edit Posting Date and Time,Zmodyfikuj datę i czas dokumentu,
-Is Paid,Zapłacone,
-Is Return (Debit Note),Jest zwrotem (nota debetowa),
-Apply Tax Withholding Amount,Zastosuj kwotę podatku u źródła,
-Accounting Dimensions ,Wymiary księgowe,
-Supplier Invoice Details,Dostawca Szczegóły faktury,
-Supplier Invoice Date,Data faktury dostawcy,
-Return Against Purchase Invoice,Powrót Against dowodu zakupu,
-Select Supplier Address,Wybierz adres dostawcy,
-Contact Person,Osoba kontaktowa,
-Select Shipping Address,Wybierz adres dostawy,
-Currency and Price List,Waluta i cennik,
-Price List Currency,Waluta cennika,
-Price List Exchange Rate,Cennik Kursowy,
-Set Accepted Warehouse,Ustaw przyjęty magazyn,
-Rejected Warehouse,Odrzucony Magazyn,
-Warehouse where you are maintaining stock of rejected items,Magazyn w którym zarządzasz odrzuconymi przedmiotami,
-Raw Materials Supplied,Dostarczone surowce,
-Supplier Warehouse,Magazyn dostawcy,
-Pricing Rules,Zasady ustalania cen,
-Supplied Items,Dostarczone przedmioty,
-Total (Company Currency),Razem (Spółka Waluta),
-Net Total (Company Currency),Łączna wartość netto (waluta firmy),
-Total Net Weight,Całkowita waga netto,
-Shipping Rule,Zasada dostawy,
-Purchase Taxes and Charges Template,Szablon podatków i opłat związanych z zakupami,
-Purchase Taxes and Charges,Podatki i opłaty kupna,
-Tax Breakup,Podział podatków,
-Taxes and Charges Calculation,Obliczanie podatków i opłat,
-Taxes and Charges Added (Company Currency),Dodano podatki i opłaty (Firmowe),
-Taxes and Charges Deducted (Company Currency),Podatki i opłaty potrącone (Firmowe),
-Total Taxes and Charges (Company Currency),Łączna kwota podatków i opłat (wg Firmy),
-Taxes and Charges Added,Dodano podatki i opłaty,
-Taxes and Charges Deducted,Podatki i opłaty potrącenia,
-Total Taxes and Charges,Łączna kwota podatków i opłat,
-Additional Discount,Dodatkowe Zniżki,
-Apply Additional Discount On,Zastosuj dodatkowe zniżki na,
-Additional Discount Amount (Company Currency),Dodatkowa kwota rabatu (waluta firmy),
-Additional Discount Percentage,Dodatkowy procent rabatu,
-Additional Discount Amount,Dodatkowa kwota rabatu,
-Grand Total (Company Currency),Całkowita suma (w walucie firmy),
-Rounding Adjustment (Company Currency),Korekta zaokrąglenia (waluta firmy),
-Rounded Total (Company Currency),Końcowa zaokrąglona kwota (waluta firmy),
-In Words (Company Currency),Słownie,
-Rounding Adjustment,Dopasowanie zaokrąglania,
-In Words,Słownie,
-Total Advance,Całość zaliczka,
-Disable Rounded Total,Wyłącz Zaokrąglanie Sumy,
-Cash/Bank Account,Konto Gotówka / Bank,
-Write Off Amount (Company Currency),Kwota Odpisu (Waluta Firmy),
-Set Advances and Allocate (FIFO),Ustaw Advances and Allocate (FIFO),
-Get Advances Paid,Uzyskaj opłacone zaliczki,
-Advances,Zaliczki,
-Terms,Warunki,
-Terms and Conditions1,Warunki1,
-Group same items,Grupa same pozycje,
-Print Language,Język drukowania,
-"Once set, this invoice will be on hold till the set date",Po ustawieniu faktura ta będzie zawieszona do wyznaczonej daty,
-Credit To,Kredytowane konto (Ma),
-Party Account Currency,Partia konto Waluta,
-Against Expense Account,Konto wydatków,
-Inter Company Invoice Reference,Numer referencyjny faktury firmy,
-Is Internal Supplier,Dostawca wewnętrzny,
-Start date of current invoice's period,Początek okresu rozliczeniowego dla faktury,
-End date of current invoice's period,Data zakończenia okresu bieżącej faktury,
-Update Auto Repeat Reference,Zaktualizuj Auto Repeat Reference,
-Purchase Invoice Advance,Wyślij Fakturę Zaliczkową / Proformę,
-Purchase Invoice Item,Przedmiot Faktury Zakupu,
-Quantity and Rate,Ilość i Wskaźnik,
-Received Qty,Otrzymana ilość,
-Accepted Qty,Akceptowana ilość,
-Rejected Qty,odrzucony szt,
-UOM Conversion Factor,Współczynnik konwersji jednostki miary,
-Discount on Price List Rate (%),Zniżka Cennik Oceń (%),
-Price List Rate (Company Currency),Wartość w cenniku (waluta firmy),
-Rate ,Stawka,
-Rate (Company Currency),Stawka (waluta firmy),
-Amount (Company Currency),Kwota (Waluta firmy),
-Is Free Item,Jest darmowym przedmiotem,
-Net Rate,Cena netto,
-Net Rate (Company Currency),Cena netto (Spółka Waluta),
-Net Amount (Company Currency),Kwota netto (Waluta Spółki),
-Item Tax Amount Included in Value,Pozycja Kwota podatku zawarta w wartości,
-Landed Cost Voucher Amount,Kwota Kosztu Voucheru,
-Raw Materials Supplied Cost,Koszt dostarczonych surowców,
-Accepted Warehouse,Przyjęty magazyn,
-Serial No,Nr seryjny,
-Rejected Serial No,Odrzucony Nr Seryjny,
-Expense Head,Szef Wydatków,
-Is Fixed Asset,Czy trwałego,
-Asset Location,Lokalizacja zasobów,
-Deferred Expense,Odroczony koszt,
-Deferred Expense Account,Rachunek odroczonego obciążenia,
-Service Stop Date,Data zatrzymania usługi,
-Enable Deferred Expense,Włącz odroczony koszt,
-Service Start Date,Data rozpoczęcia usługi,
-Service End Date,Data zakończenia usługi,
-Allow Zero Valuation Rate,Zezwalaj na zerową wartość wyceny,
-Item Tax Rate,Stawka podatku dla tej pozycji,
-Tax detail table fetched from item master as a string and stored in this field.\nUsed for Taxes and Charges,Podatki pobierane z tabeli szczegółów mistrza poz jako ciąg znaków i przechowywane w tej dziedzinie.\n Służy do podatkach i opłatach,
-Purchase Order Item,Przedmiot Zamówienia Kupna,
-Purchase Receipt Detail,Szczegóły zakupu paragonu,
-Item Weight Details,Szczegóły dotyczące wagi przedmiotu,
-Weight Per Unit,Waga na jednostkę,
-Total Weight,Waga całkowita,
-Weight UOM,Waga jednostkowa,
-Page Break,Znak końca strony,
-Consider Tax or Charge for,Rozwać Podatek albo Opłatę za,
-Valuation and Total,Wycena i kwota całkowita,
-Valuation,Wycena,
-Add or Deduct,Dodatki lub Potrącenia,
-Deduct,Odlicz,
-On Previous Row Amount,,
-On Previous Row Total,,
-On Item Quantity,Na ilość przedmiotu,
-Reference Row #,Rząd Odniesienia #,
-Is this Tax included in Basic Rate?,Czy podatek wliczony jest w opłaty?,
-"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Jeśli zaznaczone, kwota podatku zostanie wliczona w cenie Drukuj Cenę / Drukuj Podsumowanie",
-Account Head,Konto główne,
-Tax Amount After Discount Amount,Kwota podatku po odliczeniu wysokości rabatu,
-Item Wise Tax Detail ,Mądre informacje podatkowe dotyczące przedmiotu,
-"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.\n10. Add or Deduct: Whether you want to add or deduct the tax.","Standardowy szablon podatek, który może być stosowany do wszystkich transakcji kupna. Ten szablon może zawierać listę szefów podatkowych, a także innych głów wydatków jak ""Żegluga"", ""Ubezpieczenia"", ""Obsługa"" itp \n\n #### Uwaga \n\n stawki podatku zdefiniować tutaj będzie standardowa stawka podatku w odniesieniu do wszystkich pozycji ** **. Jeśli istnieją ** Pozycje **, które mają różne ceny, muszą być dodane w podatku od towaru ** ** tabeli w poz ** ** mistrza.\n\n #### Opis Kolumny \n\n 1. Obliczenie Typ: \n i - może to być na całkowita ** ** (to jest suma ilości wyjściowej).\n - ** Na Poprzedni Row Całkowita / Kwota ** (dla skumulowanych podatków lub opłat). Jeśli wybierzesz tę opcję, podatek będzie stosowana jako procent poprzedniego rzędu (w tabeli podatkowej) kwoty lub łącznie.\n - ** Rzeczywista ** (jak wspomniano).\n 2. Szef konta: księga konto, na którym podatek ten zostanie zaksięgowany \n 3. Centrum koszt: Jeżeli podatek / opłata jest dochód (jak wysyłką) lub kosztów musi zostać zaliczony na centrum kosztów.\n 4. Opis: Opis podatków (które będą drukowane w faktur / cudzysłowów).\n 5. Cena: Stawka podatku.\n 6. Kwota: Kwota podatku.\n 7. Razem: Zbiorcza sumie do tego punktu.\n 8. Wprowadź Row: Jeśli na podstawie ""Razem poprzedniego wiersza"" można wybrać numer wiersza, które będą brane jako baza do tego obliczenia (domyślnie jest to poprzednia wiersz).\n 9. Zastanów podatek lub opłatę za: W tej sekcji można określić, czy podatek / opłata jest tylko dla wyceny (nie jest częścią całości) lub tylko dla całości (nie dodaje wartości do elementu) lub oba.\n 10. Dodać lub odjąć: Czy chcesz dodać lub odjąć podatek.",
-Salary Component Account,Konto Wynagrodzenie Komponent,
-Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Domyślne konto bank / bankomat zostanie automatycznie zaktualizowana wynagrodzenia Journal Entry po wybraniu tego trybu.,
-ACC-SINV-.YYYY.-,ACC-SINV-.RRRR.-,
-Include Payment (POS),Obejmują płatności (POS),
-Offline POS Name,Offline POS Nazwa,
-Is Return (Credit Note),Jest zwrot (nota kredytowa),
-Return Against Sales Invoice,Powrót Against faktury sprzedaży,
-Update Billed Amount in Sales Order,Zaktualizuj kwotę rozliczenia w zleceniu sprzedaży,
-Customer PO Details,Szczegóły zamówienia klienta,
-Customer's Purchase Order,Klienta Zamówienia,
-Customer's Purchase Order Date,Data Zamówienia Zakupu Klienta,
-Customer Address,Adres klienta,
-Shipping Address Name,Adres do wysyłki Nazwa,
-Company Address Name,Nazwa firmy,
-Rate at which Customer Currency is converted to customer's base currency,Stawka przy użyciu której Waluta Klienta jest konwertowana do podstawowej waluty klienta,
-Rate at which Price list currency is converted to customer's base currency,Stawka przy użyciu której waluta Listy Cen jest konwertowana do podstawowej waluty klienta,
-Set Source Warehouse,Ustaw magazyn źródłowy,
-Packing List,Lista przedmiotów do spakowania,
-Packed Items,Przedmioty pakowane,
-Product Bundle Help,Produkt Bundle Pomoc,
-Time Sheet List,Czas Lista Sheet,
-Time Sheets,arkusze czasu,
-Total Billing Amount,Łączna kwota płatności,
-Sales Taxes and Charges Template,Podatki od sprzedaży i opłaty Szablon,
-Sales Taxes and Charges,Podatki i Opłaty od Sprzedaży,
-Loyalty Points Redemption,Odkupienie punktów lojalnościowych,
-Redeem Loyalty Points,Wykorzystaj punkty lojalnościowe,
-Redemption Account,Rachunek wykupu,
-Redemption Cost Center,Centrum kosztów odkupienia,
-In Words will be visible once you save the Sales Invoice.,"Słownie, będzie widoczne w fakturze sprzedaży, po zapisaniu",
-Allocate Advances Automatically (FIFO),Automatycznie przydzielaj zaliczki (FIFO),
-Get Advances Received,Uzyskaj otrzymane zaliczki,
-Base Change Amount (Company Currency),Kwota bazowa Change (Spółka waluty),
-Write Off Outstanding Amount,Nieuregulowana Wartość Odpisu,
-Terms and Conditions Details,Szczegóły regulaminu,
-Is Internal Customer,Jest klientem wewnętrznym,
-Is Discounted,Jest dyskontowany,
-Unpaid and Discounted,Nieopłacone i zniżki,
-Overdue and Discounted,Zaległe i zdyskontowane,
-Accounting Details,Dane księgowe,
-Debit To,Debetowane Konto (Winien),
-Is Opening Entry,,
-C-Form Applicable,,
-Commission Rate (%),Wartość prowizji (%),
-Sales Team1,Team Sprzedażowy1,
-Against Income Account,Konto przychodów,
-Sales Invoice Advance,Faktura Zaliczkowa,
-Advance amount,Kwota Zaliczki,
-Sales Invoice Item,Przedmiot Faktury Sprzedaży,
-Customer's Item Code,Kod Przedmiotu Klienta,
-Brand Name,Nazwa Marki,
-Qty as per Stock UOM,Ilość wg. Jednostki Miary,
-Discount and Margin,Rabat i marży,
-Rate With Margin,Rate With Margin,
-Discount (%) on Price List Rate with Margin,Zniżka (%) w Tabeli Cen Ceny z Marginesem,
-Rate With Margin (Company Currency),Stawka z depozytem zabezpieczającym (waluta spółki),
-Delivered By Supplier,Dostarczane przez Dostawcę,
-Deferred Revenue,Odroczone przychody,
-Deferred Revenue Account,Konto odroczonego przychodu,
-Enable Deferred Revenue,Włącz odroczone przychody,
-Stock Details,Zdjęcie Szczegóły,
-Customer Warehouse (Optional),Magazyn klienta (opcjonalnie),
-Available Batch Qty at Warehouse,Dostępne w Warehouse partii Ilość,
-Available Qty at Warehouse,Ilość dostępna w magazynie,
-Delivery Note Item,Przedmiot z dowodu dostawy,
-Base Amount (Company Currency),Kwota bazowa (Waluta firmy),
-Sales Invoice Timesheet,Faktura sprzedaży grafiku,
-Time Sheet,Czas Sheet,
-Billing Hours,Godziny billingowe,
-Timesheet Detail,Szczegółowy grafik,
-Tax Amount After Discount Amount (Company Currency),Kwota podatku po uwzględnieniu rabatu (waluta firmy),
-Item Wise Tax Detail,,
-Parenttype,Typ Nadrzędności,
-"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","Standardowy szablon podatek, który może być stosowany do wszystkich transakcji sprzedaży. Ten szablon może zawierać listę szefów podatkowych, a także innych głów koszty / dochodów jak ""Żegluga"", ""Ubezpieczenia"", ""Obsługa"" itp \n\n #### Uwaga \n\n Stopa Ciebie podatku definiujemy tu będzie standardowa stawka podatku w odniesieniu do wszystkich pozycji ** **. Jeśli istnieją ** Pozycje **, które mają różne ceny, muszą być dodane w podatku od towaru ** ** tabeli w poz ** ** mistrza.\n\n #### Opis Kolumny \n\n 1. Obliczenie Typ: \n i - może to być na całkowita ** ** (to jest suma ilości wyjściowej).\n - ** Na Poprzedni Row Całkowita / Kwota ** (dla skumulowanych podatków lub opłat). Jeśli wybierzesz tę opcję, podatek będzie stosowana jako procent poprzedniego rzędu (w tabeli podatkowej) kwoty lub łącznie.\n - ** Rzeczywista ** (jak wspomniano).\n 2. Szef konta: księga konto, na którym podatek ten zostanie zaksięgowany \n 3. Centrum koszt: Jeżeli podatek / opłata jest dochód (jak wysyłką) lub kosztów musi zostać zaliczony na centrum kosztów.\n 4. Opis: Opis podatków (które będą drukowane w faktur / cudzysłowów).\n 5. Cena: Stawka podatku.\n 6. Kwota: Kwota podatku.\n 7. Razem: Zbiorcza sumie do tego punktu.\n 8. Wprowadź Row: Jeśli na podstawie ""Razem poprzedniego wiersza"" można wybrać numer wiersza, które będą brane jako baza do tego obliczenia (domyślnie jest to poprzednia wiersz).\n 9. Czy to podatki zawarte w podstawowej stawki ?: Jeśli to sprawdzić, oznacza to, że podatek ten nie będzie wyświetlany pod tabelą pozycji, ale będą włączone do stawki podstawowej w głównej tabeli poz. Jest to przydatne, gdy chcesz dać cenę mieszkania (z uwzględnieniem wszystkich podatków) cenę do klientów.",
-* Will be calculated in the transaction.,* Zostanie policzony dla transakcji.,
-From No,Od Nie,
-To No,Do Nie,
-Is Company,Czy firma,
-Current State,Stan aktulany,
-Purchased,Zakupione,
-From Shareholder,Od Akcjonariusza,
-From Folio No,Z Folio nr,
-To Shareholder,Do Akcjonariusza,
-To Folio No,Do Folio Nie,
-Equity/Liability Account,Rachunek akcyjny / zobowiązanie,
-Asset Account,Konto aktywów,
-(including),(włącznie z),
-ACC-SH-.YYYY.-,ACC-SH-.RRRR.-,
-Folio no.,Numer folio,
-Address and Contacts,Adres i kontakty,
-Contact List,Lista kontaktów,
-Hidden list maintaining the list of contacts linked to Shareholder,Ukryta lista z listą kontaktów powiązanych z Akcjonariuszem,
-Specify conditions to calculate shipping amount,Określ warunki do obliczenia kwoty wysyłki,
-Shipping Rule Label,Etykieta z zasadami wysyłki i transportu,
-example: Next Day Shipping,przykład: Wysyłka następnego dnia,
-Shipping Rule Type,Typ reguły wysyłki,
-Shipping Account,Konto dostawy,
-Calculate Based On,Obliczone na podstawie,
-Fixed,Naprawiony,
-Net Weight,Waga netto,
-Shipping Amount,Ilość dostawy,
-Shipping Rule Conditions,Warunki zasady dostawy,
-Restrict to Countries,Ogranicz do krajów,
-Valid for Countries,Ważny dla krajów,
-Shipping Rule Condition,Warunek zasady dostawy,
-A condition for a Shipping Rule,Warunki wysyłki,
-From Value,Od wartości,
-To Value,Określ wartość,
-Shipping Rule Country,Zasada Wysyłka Kraj,
-Subscription Period,Okres subskrypcji,
-Subscription Start Date,Data rozpoczęcia subskrypcji,
-Cancelation Date,Data Anulowania,
-Trial Period Start Date,Data rozpoczęcia okresu próbnego,
-Trial Period End Date,Termin zakończenia okresu próbnego,
-Current Invoice Start Date,Aktualna data rozpoczęcia faktury,
-Current Invoice End Date,Aktualna data zakończenia faktury,
-Days Until Due,Dni do końca,
-Number of days that the subscriber has to pay invoices generated by this subscription,"Liczba dni, w których subskrybent musi płacić faktury wygenerowane w ramach tej subskrypcji",
-Cancel At End Of Period,Anuluj na koniec okresu,
-Generate Invoice At Beginning Of Period,Wygeneruj fakturę na początku okresu,
-Plans,Plany,
-Discounts,Rabaty,
-Additional DIscount Percentage,Dodatkowy rabat procentowy,
-Additional DIscount Amount,Kwota dodatkowego rabatu,
-Subscription Invoice,Faktura subskrypcyjna,
-Subscription Plan,Abonament abonamentowy,
-Cost,Koszt,
-Billing Interval,Okres rozliczeniowy,
-Billing Interval Count,Liczba interwałów rozliczeń,
-"Number of intervals for the interval field e.g if Interval is 'Days' and Billing Interval Count is 3, invoices will be generated every 3 days","Liczba interwałów dla pola interwałowego, np. Jeśli Interwał to &quot;Dni&quot;, a liczba interwałów rozliczeń to 3, faktury będą generowane co 3 dni",
-Payment Plan,Plan płatności,
-Subscription Plan Detail,Szczegóły abonamentu,
-Plan,Plan,
-Subscription Settings,Ustawienia subskrypcji,
-Grace Period,Okres łaski,
-Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,Liczba dni po dacie faktury upłynęła przed anulowaniem subskrypcji lub oznaczenia subskrypcji jako niepłatne,
-Prorate,Prorate,
-Tax Rule,Reguła podatkowa,
-Tax Type,Rodzaj podatku,
-Use for Shopping Cart,Służy do koszyka,
-Billing City,Rozliczenia Miasto,
-Billing County,Powiat,
-Billing State,Stan Billing,
-Billing Zipcode,Kod pocztowy do rozliczeń,
-Billing Country,Kraj fakturowania,
-Shipping City,Wysyłka Miasto,
-Shipping County,Dostawa County,
-Shipping State,Stan zakupu,
-Shipping Zipcode,Kod pocztowy wysyłki,
-Shipping Country,Wysyłka Kraj,
-Tax Withholding Account,Rachunek potrącenia podatku u źródła,
-Tax Withholding Rates,Podatki potrącane u źródła,
-Rates,Stawki,
-Tax Withholding Rate,Podatek u źródła,
-Single Transaction Threshold,Próg pojedynczej transakcji,
-Cumulative Transaction Threshold,Skumulowany próg transakcji,
-Agriculture Analysis Criteria,Kryteria analizy rolnictwa,
-Linked Doctype,Połączony Doctype,
-Water Analysis,Analiza wody,
-Soil Analysis,Analiza gleby,
-Plant Analysis,Analiza roślin,
-Fertilizer,Nawóz,
-Soil Texture,Tekstura gleby,
-Weather,Pogoda,
-Agriculture Manager,Dyrektor ds. Rolnictwa,
-Agriculture User,Użytkownik rolnictwa,
-Agriculture Task,Zadanie rolnicze,
-Task Name,Nazwa zadania,
-Start Day,Rozpocząć dzień,
-End Day,Koniec dnia,
-Holiday Management,Zarządzanie wakacjami,
-Ignore holidays,Ignoruj święta,
-Previous Business Day,Poprzedni dzień roboczy,
-Next Business Day,Następny dzień roboczy,
-Urgent,Pilne,
-Crop,Przyciąć,
-Crop Name,Nazwa uprawy,
-Scientific Name,Nazwa naukowa,
-"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Możesz tu zdefiniować wszystkie zadania, które należy wykonać dla tego zbioru. Pole dnia jest używane do wskazania dnia, w którym należy wykonać zadanie, 1 oznacza pierwszy dzień itd.",
-Crop Spacing,Odstępy między plamami,
-Crop Spacing UOM,Odstępy między plamami UOM,
-Row Spacing,Rozstaw wierszy,
-Row Spacing UOM,Rozstaw rzędów UOM,
-Perennial,Bylina,
-Biennial,Dwuletni,
-Planting UOM,Sadzenie MOM,
-Planting Area,Obszar sadzenia,
-Yield UOM,Wydajność UOM,
-Materials Required,Wymagane materiały,
-Produced Items,Produkowane przedmioty,
-Produce,Produkować,
-Byproducts,Przez produkty,
-Linked Location,Powiązana lokalizacja,
-A link to all the Locations in which the Crop is growing,"Łącze do wszystkich lokalizacji, w których rośnie uprawa",
-This will be day 1 of the crop cycle,To będzie pierwszy dzień cyklu zbiorów,
-ISO 8601 standard,Norma ISO 8601,
-Cycle Type,Typ cyklu,
-Less than a year,Mniej niż rok,
-The minimum length between each plant in the field for optimum growth,Minimalna długość między każdą rośliną w polu dla optymalnego wzrostu,
-The minimum distance between rows of plants for optimum growth,Minimalna odległość między rzędami roślin dla optymalnego wzrostu,
-Detected Diseases,Wykryto choroby,
-List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,Lista chorób wykrytych na polu. Po wybraniu automatycznie doda listę zadań do radzenia sobie z chorobą,
-Detected Disease,Wykryto chorobę,
-LInked Analysis,Analiza LInked,
-Disease,Choroba,
-Tasks Created,Zadania utworzone,
-Common Name,Nazwa zwyczajowa,
-Treatment Task,Zadanie leczenia,
-Treatment Period,Okres leczenia,
-Fertilizer Name,Nazwa nawozu,
-Density (if liquid),Gęstość (jeśli ciecz),
-Fertilizer Contents,Zawartość nawozu,
-Fertilizer Content,Zawartość nawozu,
-Linked Plant Analysis,Połączona analiza roślin,
-Linked Soil Analysis,Powiązana analiza gleby,
-Linked Soil Texture,Połączona tekstura gleby,
-Collection Datetime,Kolekcja Datetime,
-Laboratory Testing Datetime,Testowanie laboratoryjne Datetime,
-Result Datetime,Wynik Datetime,
-Plant Analysis Criterias,Kryteria analizy roślin,
-Plant Analysis Criteria,Kryteria analizy roślin,
-Minimum Permissible Value,Minimalna dopuszczalna wartość,
-Maximum Permissible Value,Maksymalna dopuszczalna wartość,
-Ca/K,Ca / K,
-Ca/Mg,Ca / Mg,
-Mg/K,Mg / K,
-(Ca+Mg)/K,(Ca + Mg) / K,
-Ca/(K+Ca+Mg),Ca / (K + Ca + Mg),
-Soil Analysis Criterias,Kryteria analizy gleby,
-Soil Analysis Criteria,Kryteria analizy gleby,
-Soil Type,Typ gleby,
-Loamy Sand,Piasek gliniasty,
-Sandy Loam,Sandy Loam,
-Loam,Ił,
-Silt Loam,Silt Loam,
-Sandy Clay Loam,Sandy Clay Loam,
-Clay Loam,Clay Loam,
-Silty Clay Loam,Silty Clay Loam,
-Sandy Clay,Sandy Clay,
-Silty Clay,Silty Clay,
-Clay Composition (%),Skład gliny (%),
-Sand Composition (%),Skład piasku (%),
-Silt Composition (%),Skład mułu (%),
-Ternary Plot,Ternary Plot,
-Soil Texture Criteria,Kryteria tekstury gleby,
-Type of Sample,Rodzaj próbki,
-Container,Pojemnik,
-Origin,Pochodzenie,
-Collection Temperature ,Temperatura zbierania,
-Storage Temperature,Temperatura przechowywania,
-Appearance,Wygląd,
-Person Responsible,Osoba odpowiedzialna,
-Water Analysis Criteria,Kryteria analizy wody,
-Weather Parameter,Parametr pogody,
-ACC-ASS-.YYYY.-,ACC-ASS-.YYYY.-,
-Asset Owner,Właściciel zasobu,
-Asset Owner Company,Asset Owner Company,
-Custodian,Kustosz,
-Disposal Date,Utylizacja Data,
-Journal Entry for Scrap,Księgowanie na złom,
-Available-for-use Date,Data przydatności do użycia,
-Calculate Depreciation,Oblicz amortyzację,
-Allow Monthly Depreciation,Zezwalaj na miesięczną amortyzację,
-Number of Depreciations Booked,Ilość amortyzacją zarezerwowano,
-Finance Books,Finanse Książki,
-Straight Line,Linia prosta,
-Double Declining Balance,Podwójne Bilans Spadek,
-Manual,podręcznik,
-Value After Depreciation,Wartość po amortyzacji,
-Total Number of Depreciations,Całkowita liczba amortyzacją,
-Frequency of Depreciation (Months),Częstotliwość Amortyzacja (miesiące),
-Next Depreciation Date,Następny Amortyzacja Data,
-Depreciation Schedule,amortyzacja Harmonogram,
-Depreciation Schedules,Rozkłady amortyzacyjne,
-Insurance details,Szczegóły ubezpieczenia,
-Policy number,Numer polisy,
-Insurer,Ubezpieczający,
-Insured value,Wartość ubezpieczenia,
-Insurance Start Date,Data rozpoczęcia ubezpieczenia,
-Insurance End Date,Data zakończenia ubezpieczenia,
-Comprehensive Insurance,Kompleksowe ubezpieczenie,
-Maintenance Required,Wymagane czynności konserwacyjne,
-Check if Asset requires Preventive Maintenance or Calibration,"Sprawdź, czy Zasób wymaga konserwacji profilaktycznej lub kalibracji",
-Booked Fixed Asset,Zarezerwowany środek trwały,
-Purchase Receipt Amount,Kup kwotę odbioru,
-Default Finance Book,Domyślna księga finansowa,
-Quality Manager,Manager Jakości,
-Asset Category Name,Zaleta Nazwa kategorii,
-Depreciation Options,Opcje amortyzacji,
-Enable Capital Work in Progress Accounting,Włącz rachunkowość kapitału w toku,
-Finance Book Detail,Finanse Książka szczegółów,
-Asset Category Account,Konto Aktywów Kategoria,
-Fixed Asset Account,Konto trwałego,
-Accumulated Depreciation Account,Skumulowana Amortyzacja konta,
-Depreciation Expense Account,Konto amortyzacji wydatków,
-Capital Work In Progress Account,Kapitałowe konto w toku,
-Asset Finance Book,Książka o finansach aktywów,
-Written Down Value,Zapisana wartość,
-Expected Value After Useful Life,Przewidywany okres użytkowania wartości po,
-Rate of Depreciation,Stopa amortyzacji,
-In Percentage,W procentach,
-Maintenance Team,Zespół serwisowy,
-Maintenance Manager Name,Nazwa menedżera konserwacji,
-Maintenance Tasks,Zadania konserwacji,
-Manufacturing User,Produkcja użytkownika,
-Asset Maintenance Log,Dziennik konserwacji zasobów,
-ACC-AML-.YYYY.-,ACC-AML-.RRRR.-,
-Maintenance Type,Typ Konserwacji,
-Maintenance Status,Status Konserwacji,
-Planned,Zaplanowany,
-Has Certificate ,Posiada certyfikat,
-Certificate,Certyfikat,
-Actions performed,Wykonane akcje,
-Asset Maintenance Task,Zadanie utrzymania aktywów,
-Maintenance Task,Zadanie konserwacji,
-Preventive Maintenance,Konserwacja zapobiegawcza,
-Calibration,Kalibrowanie,
-2 Yearly,2 Rocznie,
-Certificate Required,Wymagany certyfikat,
-Assign to Name,Przypisz do nazwy,
-Next Due Date,Następna data płatności,
-Last Completion Date,Ostatnia data ukończenia,
-Asset Maintenance Team,Zespół ds. Utrzymania aktywów,
-Maintenance Team Name,Nazwa zespołu obsługi technicznej,
-Maintenance Team Members,Członkowie zespołu ds. Konserwacji,
-Purpose,Cel,
-Stock Manager,Kierownik magazynu,
-Asset Movement Item,Element ruchu zasobu,
-Source Location,Lokalizacja źródła,
-From Employee,Od pracownika,
-Target Location,Docelowa lokalizacja,
-To Employee,Do pracownika,
-Asset Repair,Naprawa aktywów,
-ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-,
-Failure Date,Data awarii,
-Assign To Name,Przypisywanie do nazwy,
-Repair Status,Status naprawy,
-Error Description,Opis błędu,
-Downtime,Przestój,
-Repair Cost,koszty naprawy,
-Manufacturing Manager,Kierownik Produkcji,
-Current Asset Value,Aktualna wartość aktywów,
-New Asset Value,Nowa wartość aktywów,
-Make Depreciation Entry,Bądź Amortyzacja Entry,
-Finance Book Id,Identyfikator książki finansowej,
-Location Name,Nazwa lokalizacji,
-Parent Location,Lokalizacja rodzica,
-Is Container,To kontener,
-Check if it is a hydroponic unit,"Sprawdź, czy to jednostka hydroponiczna",
-Location Details,Szczegóły lokalizacji,
-Latitude,Szerokość,
-Longitude,Długość geograficzna,
-Area,Powierzchnia,
-Area UOM,Obszar UOM,
-Tree Details,drzewo Szczegóły,
-Maintenance Team Member,Członek zespołu ds. Konserwacji,
-Team Member,Członek zespołu,
-Maintenance Role,Rola konserwacji,
-Buying Settings,Ustawienia zakupów,
-Settings for Buying Module,Ustawienia Zakup modułu,
-Supplier Naming By,Po nazwie dostawcy,
-Default Supplier Group,Domyślna grupa dostawców,
-Default Buying Price List,Domyślny cennik dla zakupów,
-Backflush Raw Materials of Subcontract Based On,Rozliczenie wsteczne materiałów podwykonawstwa,
-Material Transferred for Subcontract,Materiał przekazany do podwykonawstwa,
-Over Transfer Allowance (%),Nadwyżka limitu transferu (%),
-Percentage you are allowed to transfer more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to transfer 110 units.,"Procent, który możesz przekazać więcej w stosunku do zamówionej ilości. Na przykład: jeśli zamówiłeś 100 jednostek. a Twój zasiłek wynosi 10%, możesz przenieść 110 jednostek.",
-PUR-ORD-.YYYY.-,PUR-ORD-.YYYY.-,
-Get Items from Open Material Requests,Elementy z żądań Otwórz Materiał,
-Fetch items based on Default Supplier.,Pobierz elementy na podstawie domyślnego dostawcy.,
-Required By,Wymagane przez,
-Order Confirmation No,Potwierdzenie nr,
-Order Confirmation Date,Zamów datę potwierdzenia,
-Customer Mobile No,Komórka klienta Nie,
-Customer Contact Email,Kontakt z klientem e-mail,
-Set Target Warehouse,Ustaw magazyn docelowy,
-Sets 'Warehouse' in each row of the Items table.,Ustawia „Magazyn” w każdym wierszu tabeli Towary.,
-Supply Raw Materials,Zaopatrzenia w surowce,
-Purchase Order Pricing Rule,Reguła cenowa zamówienia zakupu,
-Set Reserve Warehouse,Ustaw Rezerwuj magazyn,
-In Words will be visible once you save the Purchase Order.,Słownie będzie widoczna w Zamówieniu po zapisaniu,
-Advance Paid,Zaliczka,
-Tracking,Śledzenie,
-% Billed,% rozliczonych,
-% Received,% Otrzymanych,
-Ref SQ,Ref SQ,
-Inter Company Order Reference,Informacje o zamówieniach między firmami,
-Supplier Part Number,Numer katalogowy dostawcy,
-Billed Amt,Rozliczona Ilość,
-Warehouse and Reference,Magazyn i punkt odniesienia,
-To be delivered to customer,Być dostarczone do klienta,
-Material Request Item,,
-Supplier Quotation Item,,
-Against Blanket Order,Przeciw Kocowi,
-Blanket Order,Formularz zamówienia,
-Blanket Order Rate,Ogólny koszt zamówienia,
-Returned Qty,Wrócił szt,
-Purchase Order Item Supplied,Dostarczony przedmiot zamówienia,
-BOM Detail No,BOM Numer,
-Stock Uom,Jednostka,
-Raw Material Item Code,Kod surowca,
-Supplied Qty,Dostarczane szt,
-Purchase Receipt Item Supplied,Rachunek Kupna Zaopatrzenia,
-Current Stock,Bieżący asortyment,
-PUR-RFQ-.YYYY.-,PUR-RFQ-.RRRR.-,
-For individual supplier,Dla indywidualnego dostawcy,
-Link to Material Requests,Link do żądań materiałów,
-Message for Supplier,Wiadomość dla dostawcy,
-Request for Quotation Item,Przedmiot zapytania ofertowego,
-Required Date,Data wymagana,
-Request for Quotation Supplier,Zapytanie ofertowe do dostawcy,
-Send Email,Wyślij E-mail,
-Quote Status,Status statusu,
-Download PDF,Pobierz PDF,
-Supplier of Goods or Services.,Dostawca towarów lub usług.,
-Name and Type,Nazwa i typ,
-SUP-.YYYY.-,SUP-.RRRR.-,
-Default Bank Account,Domyślne konto bankowe,
-Is Transporter,Dostarcza we własnym zakresie,
-Represents Company,Reprezentuje firmę,
-Supplier Type,Typ dostawcy,
-Allow Purchase Invoice Creation Without Purchase Order,Zezwalaj na tworzenie faktur zakupu bez zamówienia zakupu,
-Allow Purchase Invoice Creation Without Purchase Receipt,Zezwalaj na tworzenie faktur zakupu bez pokwitowania zakupu,
-Warn RFQs,Informuj o złożonych zapytaniach ofertowych,
-Warn POs,Informuj o złożonych zamówieniach,
-Prevent RFQs,Zapobiegaj złożeniu zapytania ofertowego,
-Prevent POs,Zapobiegaj złożeniu zamówienia,
-Billing Currency,Waluta rozliczenia,
-Default Payment Terms Template,Domyślny szablon warunków płatności,
-Block Supplier,Blokuj dostawcę,
-Hold Type,Hold Type,
-Leave blank if the Supplier is blocked indefinitely,"Pozostaw puste, jeśli dostawca jest blokowany na czas nieokreślony",
-Default Payable Accounts,Domyślne konta Rozrachunki z dostawcami,
-Mention if non-standard payable account,"Wspomnij, jeśli nietypowe konto płatne",
-Default Tax Withholding Config,Domyślna konfiguracja podatku u źródła,
-Supplier Details,Szczegóły dostawcy,
-Statutory info and other general information about your Supplier,Informacje prawne na temat dostawcy,
-PUR-SQTN-.YYYY.-,PUR-SQTN-.RRRR.-,
-Supplier Address,Adres dostawcy,
-Link to material requests,Link do żądań materialnych,
-Rounding Adjustment (Company Currency,Korekta zaokrągleń (waluta firmy,
-Auto Repeat Section,Sekcja automatycznego powtarzania,
-Is Subcontracted,Czy zlecony,
-Lead Time in days,Czas oczekiwania w dniach,
-Supplier Score,Ocena Dostawcy,
-Indicator Color,Kolor wskaźnika,
-Evaluation Period,Okres próbny,
-Per Week,Na tydzień,
-Per Month,Na miesiąc,
-Per Year,Na rok,
-Scoring Setup,Konfiguracja punktów,
-Weighting Function,Funkcja ważenia,
-"Scorecard variables can be used, as well as:\n{total_score} (the total score from that period),\n{period_number} (the number of periods to present day)\n","Mogą być stosowane zmienne kartoteki, a także: {total_score} (całkowity wynik z tego okresu), {period_number} (liczba okresów na dzień dzisiejszy)",
-Scoring Standings,Zaplanuj miejsca,
-Criteria Setup,Konfiguracja kryteriów,
-Load All Criteria,Załaduj wszystkie kryteria,
-Scoring Criteria,Kryteria oceny,
-Scorecard Actions,Działania kartoteki,
-Warn for new Request for Quotations,Ostrzegaj przed nowym żądaniem ofert,
-Warn for new Purchase Orders,Ostrzegaj o nowych zamówieniach zakupu,
-Notify Supplier,Powiadom o Dostawcy,
-Notify Employee,Powiadom o pracowniku,
-Supplier Scorecard Criteria,Kryteria oceny dostawcy Dostawcy,
-Criteria Name,Kryteria Nazwa,
-Max Score,Maksymalny wynik,
-Criteria Formula,Wzór Kryterium,
-Criteria Weight,Kryteria Waga,
-Supplier Scorecard Period,Okres kartoteki dostawcy,
-PU-SSP-.YYYY.-,PU-SSP-.YYYY.-,
-Period Score,Wynik okresu,
-Calculations,Obliczenia,
-Criteria,Kryteria,
-Variables,Zmienne,
-Supplier Scorecard Setup,Ustawienia karty wyników dostawcy,
-Supplier Scorecard Scoring Criteria,Kryteria oceny scoringowej dostawcy,
-Score,Wynik,
-Supplier Scorecard Scoring Standing,Dostawca Scorecard Stanowisko,
-Standing Name,Reputacja,
-Purple,Fioletowy,
-Yellow,Żółty,
-Orange,Pomarańczowy,
-Min Grade,Min. wynik,
-Max Grade,Maks. wynik,
-Warn Purchase Orders,Ostrzegaj Zamówienia Zakupu,
-Prevent Purchase Orders,Zapobiegaj zamówieniom zakupu,
-Employee ,Pracownik,
-Supplier Scorecard Scoring Variable,Dostawca Scorecard Zmienna scoringowa,
-Variable Name,Nazwa zmiennej,
-Parameter Name,Nazwa parametru,
-Supplier Scorecard Standing,Dostawca Scorecard Standing,
-Notify Other,Powiadamiaj inne,
-Supplier Scorecard Variable,Zmienną Scorecard dostawcy,
-Call Log,Rejestr połączeń,
-Received By,Otrzymane przez,
-Caller Information,Informacje o dzwoniącym,
-Contact Name,Nazwa kontaktu,
-Lead ,Prowadzić,
-Lead Name,Nazwa Tropu,
-Ringing,Dzwonienie,
-Missed,Nieodebrane,
-Call Duration in seconds,Czas trwania połączenia w sekundach,
-Recording URL,Adres URL nagrywania,
-Communication Medium,Środki komunikacji,
-Communication Medium Type,Typ medium komunikacyjnego,
-Voice,Głos,
-Catch All,Złap wszystkie,
-"If there is no assigned timeslot, then communication will be handled by this group","Jeśli nie ma przypisanej szczeliny czasowej, komunikacja będzie obsługiwana przez tę grupę",
-Timeslots,Szczeliny czasowe,
-Communication Medium Timeslot,Średni czas komunikacji,
-Employee Group,Grupa pracowników,
-Appointment,Spotkanie,
-Scheduled Time,Zaplanowany czas,
-Unverified,Niesprawdzony,
-Customer Details,Dane Klienta,
-Phone Number,Numer telefonu,
-Skype ID,Nazwa Skype,
-Linked Documents,Powiązane dokumenty,
-Appointment With,Spotkanie z,
-Calendar Event,Wydarzenie z kalendarza,
-Appointment Booking Settings,Ustawienia rezerwacji terminu,
-Enable Appointment Scheduling,Włącz harmonogram spotkań,
-Agent Details,Dane agenta,
-Availability Of Slots,Dostępność automatów,
-Number of Concurrent Appointments,Liczba jednoczesnych spotkań,
-Agents,Agenci,
-Appointment Details,Szczegóły terminu,
-Appointment Duration (In Minutes),Czas trwania spotkania (w minutach),
-Notify Via Email,Powiadom przez e-mail,
-Notify customer and agent via email on the day of the appointment.,Powiadom klienta i agenta za pośrednictwem poczty elektronicznej w dniu spotkania.,
-Number of days appointments can be booked in advance,Liczbę dni można umawiać z wyprzedzeniem,
-Success Settings,Ustawienia sukcesu,
-Success Redirect URL,Sukces Przekierowanie URL,
-"Leave blank for home.\nThis is relative to site URL, for example ""about"" will redirect to ""https://yoursitename.com/about""","Pozostaw puste w domu. Jest to względne w stosunku do adresu URL witryny, na przykład „about” przekieruje na „https://yoursitename.com/about”",
-Appointment Booking Slots,Terminy rezerwacji spotkań,
-Day Of Week,Dzień tygodnia,
-From Time ,Od czasu,
-Campaign Email Schedule,Harmonogram e-mailu kampanii,
-Send After (days),Wyślij po (dni),
-Signed,Podpisano,
-Party User,Użytkownik strony,
-Unsigned,Bez podpisu,
-Fulfilment Status,Status realizacji,
-N/A,Nie dotyczy,
-Unfulfilled,Niespełnione,
-Partially Fulfilled,Częściowo zrealizowane,
-Fulfilled,Spełniony,
-Lapsed,Nieaktualne,
-Contract Period,Okres umowy,
-Signee Details,Szczegóły dotyczące Signee,
-Signee,Signee,
-Signed On,Podpisano,
-Contract Details,Szczegóły umowy,
-Contract Template,Szablon umowy,
-Contract Terms,Warunki kontraktu,
-Fulfilment Details,Szczegóły realizacji,
-Requires Fulfilment,Wymaga spełnienia,
-Fulfilment Deadline,Termin realizacji,
-Fulfilment Terms,Warunki realizacji,
-Contract Fulfilment Checklist,Lista kontrolna realizacji kontraktu,
-Requirement,Wymaganie,
-Contract Terms and Conditions,Warunki umowy,
-Fulfilment Terms and Conditions,Spełnienie warunków,
-Contract Template Fulfilment Terms,Warunki realizacji szablonu umowy,
-Email Campaign,Kampania e-mailowa,
-Email Campaign For ,Kampania e-mailowa dla,
-Lead is an Organization,Ołów to organizacja,
-CRM-LEAD-.YYYY.-,CRM-LEAD-.RRRR.-,
-Person Name,Imię i nazwisko osoby,
-Lost Quotation,Przegrana notowań,
-Interested,Jestem zainteresowany,
-Converted,Przekształcono,
-Do Not Contact,Nie Kontaktuj,
-From Customer,Od klienta,
-Campaign Name,Nazwa kampanii,
-Follow Up,Zagryźć,
-Next Contact By,Następny Kontakt Po,
-Next Contact Date,Data Następnego Kontaktu,
-Ends On,Koniec w dniu,
-Address & Contact,Adres i kontakt,
-Mobile No.,Nr tel. Komórkowego,
-Lead Type,Typ Tropu,
-Channel Partner,,
-Consultant,Konsultant,
-Market Segment,Segment rynku,
-Industry,Przedsiębiorstwo,
-Request Type,Typ zapytania,
-Product Enquiry,Zapytanie o produkt,
-Request for Information,Prośba o informację,
-Suggestions,Sugestie,
-Blog Subscriber,Subskrybent Bloga,
-LinkedIn Settings,Ustawienia LinkedIn,
-Company ID,identyfikator firmy,
-OAuth Credentials,Poświadczenia OAuth,
-Consumer Key,Klucz klienta,
-Consumer Secret,Sekret konsumenta,
-User Details,Dane użytkownika,
-Person URN,Osoba URN,
-Session Status,Stan sesji,
-Lost Reason Detail,Szczegóły utraconego powodu,
-Opportunity Lost Reason,Możliwość utracona z powodu,
-Potential Sales Deal,Szczegóły potencjalnych sprzedaży,
-CRM-OPP-.YYYY.-,CRM-OPP-.RRRR.-,
-Opportunity From,Szansa od,
-Customer / Lead Name,Nazwa Klienta / Tropu,
-Opportunity Type,Typ szansy,
-Converted By,Przekształcony przez,
-Sales Stage,Etap sprzedaży,
-Lost Reason,Powód straty,
-Expected Closing Date,Oczekiwana data zamknięcia,
-To Discuss,Do omówienia,
-With Items,Z przedmiotami,
-Probability (%),Prawdopodobieństwo (%),
-Contact Info,Dane kontaktowe,
-Customer / Lead Address,Adres Klienta / Tropu,
-Contact Mobile No,Numer komórkowy kontaktu,
-Enter name of campaign if source of enquiry is campaign,Wpisz nazwę przeprowadzanej kampanii jeżeli źródło pytania jest kampanią,
-Opportunity Date,Data szansy,
-Opportunity Item,Przedmiot Szansy,
-Basic Rate,Podstawowy wskaźnik,
-Stage Name,Pseudonim artystyczny,
-Social Media Post,Post w mediach społecznościowych,
-Post Status,Stan publikacji,
-Posted,Wysłano,
-Share On,Podziel się na,
-Twitter,Świergot,
-LinkedIn,LinkedIn,
-Twitter Post Id,Identyfikator posta na Twitterze,
-LinkedIn Post Id,Identyfikator posta na LinkedIn,
-Tweet,Ćwierkać,
-Twitter Settings,Ustawienia Twittera,
-API Secret Key,Tajny klucz API,
-Term Name,Nazwa Term,
-Term Start Date,Termin Data rozpoczęcia,
-Term End Date,Term Data zakończenia,
-Academics User,Studenci,
-Academic Year Name,Nazwa Roku Akademickiego,
-Article,Artykuł,
-LMS User,Użytkownik LMS,
-Assessment Criteria Group,Kryteria oceny grupowej,
-Assessment Group Name,Nazwa grupy Assessment,
-Parent Assessment Group,Rodzic Assesment Group,
-Assessment Name,Nazwa ocena,
-Grading Scale,Skala ocen,
-Examiner,Egzaminator,
-Examiner Name,Nazwa Examiner,
-Supervisor,Kierownik,
-Supervisor Name,Nazwa Supervisor,
-Evaluate,Oceniać,
-Maximum Assessment Score,Maksymalny wynik oceny,
-Assessment Plan Criteria,Kryteria oceny planu,
-Maximum Score,Maksymalna liczba punktów,
-Result,Wynik,
-Total Score,Całkowity wynik,
-Grade,Stopień,
-Assessment Result Detail,Wynik oceny Szczegóły,
-Assessment Result Tool,Wynik oceny Narzędzie,
-Result HTML,wynik HTML,
-Content Activity,Aktywność treści,
-Last Activity ,Ostatnia aktywność,
-Content Question,Pytanie dotyczące treści,
-Question Link,Link do pytania,
-Course Name,Nazwa przedmiotu,
-Topics,Tematy,
-Hero Image,Obraz bohatera,
-Default Grading Scale,Domyślna skala ocen,
-Education Manager,Menedżer edukacji,
-Course Activity,Aktywność na kursie,
-Course Enrollment,Rejestracja kursu,
-Activity Date,Data aktywności,
-Course Assessment Criteria,Kryteria oceny kursu,
-Weightage,Waga/wiek,
-Course Content,Zawartość kursu,
-Quiz,Kartkówka,
-Program Enrollment,Rejestracja w programie,
-Enrollment Date,Data rejestracji,
-Instructor Name,Instruktor Nazwa,
-EDU-CSH-.YYYY.-,EDU-CSH-.RRRR.-,
-Course Scheduling Tool,Oczywiście Narzędzie Scheduling,
-Course Start Date,Data rozpoczęcia kursu,
-To TIme,Do czasu,
-Course End Date,Data zakończenia kursu,
-Course Topic,Temat kursu,
-Topic,Temat,
-Topic Name,Nazwa tematu,
-Education Settings,Ustawienia edukacji,
-Current Academic Year,Obecny Rok Akademicki,
-Current Academic Term,Obecny termin akademicki,
-Attendance Freeze Date,Data zamrożenia obecności,
-Validate Batch for Students in Student Group,Sprawdź partię dla studentów w grupie studentów,
-"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Dla grupy studentów opartej na partiach, partia ucznia zostanie zatwierdzona dla każdego ucznia z wpisu do programu.",
-Validate Enrolled Course for Students in Student Group,Zatwierdzić zapisany kurs dla studentów w grupie studentów,
-"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",Dla Grupy Studenckiej na Kursie kurs zostanie sprawdzony dla każdego Uczestnika z zapisanych kursów w ramach Rejestracji Programu.,
-Make Academic Term Mandatory,Uczyń okres akademicki obowiązkowym,
-"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Jeśli opcja jest włączona, pole Akademickie oznaczenie będzie obowiązkowe w narzędziu rejestrowania programu.",
-Skip User creation for new Student,Pomiń tworzenie użytkownika dla nowego Studenta,
-"By default, a new User is created for every new Student. If enabled, no new User will be created when a new Student is created.","Domyślnie dla każdego nowego Studenta tworzony jest nowy Użytkownik. Jeśli ta opcja jest włączona, żaden nowy Użytkownik nie zostanie utworzony po utworzeniu nowego Studenta.",
-Instructor Records to be created by,"Rekord instruktorski, który zostanie utworzony przez",
-Employee Number,Numer pracownika,
-Fee Category,opłata Kategoria,
-Fee Component,opłata Komponent,
-Fees Category,Opłaty Kategoria,
-Fee Schedule,Harmonogram opłat,
-Fee Structure,Struktura opłat,
-EDU-FSH-.YYYY.-,EDU-FSH-.YYYY.-,
-Fee Creation Status,Status tworzenia licencji,
-In Process,W trakcie,
-Send Payment Request Email,Wyślij e-mail z zapytaniem o płatność,
-Student Category,Student Kategoria,
-Fee Breakup for each student,Podział wynagrodzenia dla każdego ucznia,
-Total Amount per Student,Łączna kwota na jednego studenta,
-Institution,Instytucja,
-Fee Schedule Program,Program planu opłat,
-Student Batch,Batch Student,
-Total Students,Wszystkich studentów,
-Fee Schedule Student Group,Plan zajęć grupy studentów,
-EDU-FST-.YYYY.-,EDU-FST-.YYYY.-,
-EDU-FEE-.YYYY.-,EDU-FEE-.YYYY.-,
-Include Payment,Dołącz płatności,
-Send Payment Request,Wyślij żądanie płatności,
-Student Details,Szczegóły Uczniów,
-Student Email,E-mail dla studentów,
-Grading Scale Name,Skala ocen Nazwa,
-Grading Scale Intervals,Odstępy Skala ocen,
-Intervals,przedziały,
-Grading Scale Interval,Skala ocen Interval,
-Grade Code,Kod klasy,
-Threshold,Próg,
-Grade Description,Stopień Opis,
-Guardian,Opiekun,
-Guardian Name,Nazwa Stróża,
-Alternate Number,Alternatywny numer,
-Occupation,Zawód,
-Work Address,Adres miejsca pracy,
-Guardian Of ,Strażnik,
-Students,studenci,
-Guardian Interests,opiekun Zainteresowania,
-Guardian Interest,Strażnik Odsetki,
-Interest,Zainteresowanie,
-Guardian Student,opiekun studenta,
-EDU-INS-.YYYY.-,EDU-INS-.YYYY.-,
-Instructor Log,Dziennik instruktora,
-Other details,Pozostałe szczegóły,
-Option,Opcja,
-Is Correct,Jest poprawne,
-Program Name,Nazwa programu,
-Program Abbreviation,Skrót programu,
-Courses,Pola,
-Is Published,Jest opublikowany,
-Allow Self Enroll,Zezwalaj na samodzielne zapisywanie się,
-Is Featured,Jest zawarty,
-Intro Video,Intro Video,
-Program Course,Program kursu,
-School House,school House,
-Boarding Student,Student Wyżywienia,
-Check this if the Student is residing at the Institute's Hostel.,"Sprawdź, czy Student mieszka w Hostelu Instytutu.",
-Walking,Pieszy,
-Institute's Bus,Autobus Instytutu,
-Public Transport,Transport publiczny,
-Self-Driving Vehicle,Samochód osobowy,
-Pick/Drop by Guardian,Pick / Drop przez Guardian,
-Enrolled courses,Zaplanowane kursy,
-Program Enrollment Course,Kurs rekrutacji,
-Program Enrollment Fee,Program Rejestracji Opłata,
-Program Enrollment Tool,Rejestracja w programie Narzędzie,
-Get Students From,Uzyskaj studentów z,
-Student Applicant,Student Wnioskodawca,
-Get Students,Uzyskaj Studentów,
-Enrollment Details,Szczegóły rejestracji,
-New Program,Nowy program,
-New Student Batch,Nowa partia studencka,
-Enroll Students,zapisać studentów,
-New Academic Year,Nowy rok akademicki,
-New Academic Term,Nowy okres akademicki,
-Program Enrollment Tool Student,Rejestracja w programie Narzędzie Student,
-Student Batch Name,Student Batch Nazwa,
-Program Fee,Opłata Program,
-Question,Pytanie,
-Single Correct Answer,Pojedyncza poprawna odpowiedź,
-Multiple Correct Answer,Wielokrotna poprawna odpowiedź,
-Quiz Configuration,Konfiguracja quizu,
-Passing Score,Wynik pozytywny,
-Score out of 100,Wynik na 100,
-Max Attempts,Max Próby,
-Enter 0 to waive limit,"Wprowadź 0, aby zrezygnować z limitu",
-Grading Basis,Podstawa klasyfikacji,
-Latest Highest Score,Najnowszy najwyższy wynik,
-Latest Attempt,Ostatnia próba,
-Quiz Activity,Aktywność Quiz,
-Enrollment,Rekrutacja,
-Pass,Przechodzić,
-Quiz Question,Pytanie do quizu,
-Quiz Result,Wynik testu,
-Selected Option,Wybrana opcja,
-Correct,Poprawny,
-Wrong,Źle,
-Room Name,Nazwa pokoju,
-Room Number,Numer pokoju,
-Seating Capacity,Liczba miejsc,
-House Name,Nazwa domu,
-EDU-STU-.YYYY.-,EDU-STU-.RRRR.-,
-Student Mobile Number,Student Mobile Number,
-Joining Date,Data Dołączenia,
-Blood Group,Grupa Krwi,
-A+,A+,
-A-,A-,
-B+,B +,
-B-,B-,
-O+,O +,
-O-,O-,
-AB+,AB +,
-AB-,AB-,
-Nationality,Narodowość,
-Home Address,Adres domowy,
-Guardian Details,Szczegóły Stróża,
-Guardians,Strażnicy,
-Sibling Details,rodzeństwo Szczegóły,
-Siblings,Rodzeństwo,
-Exit,Wyjście,
-Date of Leaving,Data Pozostawiając,
-Leaving Certificate Number,Pozostawiając numer certyfikatu,
-Reason For Leaving,Powód odejścia,
-Student Admission,Wstęp Student,
-Admission Start Date,Wstęp Data rozpoczęcia,
-Admission End Date,Wstęp Data zakończenia,
-Publish on website,Opublikuj na stronie internetowej,
-Eligibility and Details,Kwalifikowalność i szczegóły,
-Student Admission Program,Studencki program przyjęć,
-Minimum Age,Minimalny wiek,
-Maximum Age,Maksymalny wiek,
-Application Fee,Opłata za zgłoszenie,
-Naming Series (for Student Applicant),Naming Series (dla Studenta Wnioskodawcy),
-LMS Only,Tylko LMS,
-EDU-APP-.YYYY.-,EDU-APP-.RRRR.-,
-Application Status,Status aplikacji,
-Application Date,Data złożenia wniosku,
-Student Attendance Tool,Obecność Student Narzędzie,
-Group Based On,Grupa oparta na,
-Students HTML,studenci HTML,
-Group Based on,Grupa oparta na,
-Student Group Name,Nazwa grupy studentów,
-Max Strength,Maksymalna siła,
-Set 0 for no limit,Ustaw 0 oznacza brak limitu,
-Instructors,instruktorzy,
-Student Group Creation Tool,Narzędzie tworzenia grupy studenta,
-Leave blank if you make students groups per year,"Zostaw puste, jeśli uczysz grupy studentów rocznie",
-Get Courses,Uzyskaj kursy,
-Separate course based Group for every Batch,Oddzielna grupa kursów dla każdej partii,
-Leave unchecked if you don't want to consider batch while making course based groups. ,"Opuść zaznaczenie, jeśli nie chcesz rozważyć partii przy jednoczesnym tworzeniu grup kursów.",
-Student Group Creation Tool Course,Kurs grupy studentów Stworzenie narzędzia,
-Course Code,Kod kursu,
-Student Group Instructor,Instruktor grupy studentów,
-Student Group Student,Student Grupa Student,
-Group Roll Number,Numer grupy,
-Student Guardian,Student Stróża,
-Relation,Relacja,
-Mother,Mama,
-Father,Ojciec,
-Student Language,Student Język,
-Student Leave Application,Student Application Leave,
-Mark as Present,Oznacz jako Present,
-Student Log,Dziennik studenta,
-Academic,Akademicki,
-Achievement,Osiągnięcie,
-Student Report Generation Tool,Narzędzie do generowania raportów uczniów,
-Include All Assessment Group,Uwzględnij całą grupę oceny,
-Show Marks,Pokaż znaczniki,
-Add letterhead,Dodaj papier firmowy,
-Print Section,Sekcja drukowania,
-Total Parents Teacher Meeting,Spotkanie nauczycieli wszystkich rodziców,
-Attended by Parents,Uczestniczyli w nim rodzice,
-Assessment Terms,Warunki oceny,
-Student Sibling,Student Rodzeństwo,
-Studying in Same Institute,Studia w sam instytut,
-NO,NIE,
-YES,Tak,
-Student Siblings,Rodzeństwo studenckie,
-Topic Content,Treść tematu,
-Amazon MWS Settings,Ustawienia Amazon MWS,
-ERPNext Integrations,Integracje ERPNext,
-Enable Amazon,Włącz Amazon,
-MWS Credentials,Poświadczenia MWS,
-Seller ID,ID sprzedawcy,
-AWS Access Key ID,AWS Access Key ID,
-MWS Auth Token,MWh Auth Token,
-Market Place ID,Identyfikator rynku,
-AE,AE,
-AU,AU,
-BR,BR,
-CA,CA,
-CN,CN,
-DE,DE,
-ES,ES,
-FR,FR,
-IN,W,
-JP,JP,
-IT,TO,
-MX,MX,
-UK,Wielka Brytania,
-US,NAS,
-Customer Type,typ klienta,
-Market Place Account Group,Grupa konta rynkowego,
-After Date,Po dacie,
-Amazon will synch data updated after this date,Amazon zsynchronizuje dane zaktualizowane po tej dacie,
-Sync Taxes and Charges,Synchronizuj podatki i opłaty,
-Get financial breakup of Taxes and charges data by Amazon ,Uzyskaj rozpad finansowy danych podatkowych i obciążeń przez Amazon,
-Sync Products,Synchronizuj produkty,
-Always sync your products from Amazon MWS before synching the Orders details,Zawsze synchronizuj swoje produkty z Amazon MWS przed zsynchronizowaniem szczegółów Zamówienia,
-Sync Orders,Synchronizuj zamówienia,
-Click this button to pull your Sales Order data from Amazon MWS.,"Kliknij ten przycisk, aby pobrać dane zamówienia sprzedaży z Amazon MWS.",
-Enable Scheduled Sync,Włącz zaplanowaną synchronizację,
-Check this to enable a scheduled Daily synchronization routine via scheduler,"Zaznacz to ustawienie, aby włączyć zaplanowaną codzienną procedurę synchronizacji za pośrednictwem programu planującego",
-Max Retry Limit,Maksymalny limit ponownych prób,
-Exotel Settings,Ustawienia Exotel,
-Account SID,SID konta,
-API Token,Token API,
-GoCardless Mandate,Upoważnienie GoCardless,
-Mandate,Mandat,
-GoCardless Customer,Klient bez karty,
-GoCardless Settings,Ustawienia bez karty,
-Webhooks Secret,Sekret Webhooks,
-Plaid Settings,Ustawienia Plaid,
-Synchronize all accounts every hour,Synchronizuj wszystkie konta co godzinę,
-Plaid Client ID,Identyfikator klienta w kratkę,
-Plaid Secret,Plaid Secret,
-Plaid Environment,Plaid Environment,
-sandbox,piaskownica,
-development,rozwój,
-production,produkcja,
-QuickBooks Migrator,QuickBooks Migrator,
-Application Settings,Ustawienia aplikacji,
-Token Endpoint,Token Endpoint,
-Scope,Zakres,
-Authorization Settings,Ustawienia autoryzacji,
-Authorization Endpoint,Punkt końcowy autoryzacji,
-Authorization URL,Adres URL autoryzacji,
-Quickbooks Company ID,Quickbooks Identyfikator firmy,
-Company Settings,Ustawienia firmy,
-Default Shipping Account,Domyślne konto wysyłkowe,
-Default Warehouse,Domyślny magazyn,
-Default Cost Center,Domyślne Centrum Kosztów,
-Undeposited Funds Account,Rachunek nierozliczonych funduszy,
-Shopify Log,Shopify Log,
-Request Data,Żądaj danych,
-Shopify Settings,Zmień ustawienia,
-status html,status html,
-Enable Shopify,Włącz Shopify,
-App Type,Typ aplikacji,
-Last Sync Datetime,Ostatnia synchronizacja Datetime,
-Shop URL,URL sklepu,
-eg: frappe.myshopify.com,np .: frappe.myshopify.com,
-Shared secret,Wspólny sekret,
-Webhooks Details,Szczegóły Webhooks,
-Webhooks,Webhooks,
-Customer Settings,Ustawienia klienta,
-Default Customer,Domyślny klient,
-Customer Group will set to selected group while syncing customers from Shopify,Grupa klientów ustawi wybraną grupę podczas synchronizowania klientów z Shopify,
-For Company,Dla firmy,
-Cash Account will used for Sales Invoice creation,Konto gotówkowe zostanie użyte do utworzenia faktury sprzedaży,
-Update Price from Shopify To ERPNext Price List,Zaktualizuj cenę z Shopify To ERPNext Price List,
-Default Warehouse to to create Sales Order and Delivery Note,"Domyślny magazyn, aby utworzyć zamówienie sprzedaży i dostawę",
-Sales Order Series,Seria zamówień sprzedaży,
-Import Delivery Notes from Shopify on Shipment,Importuj notatki dostawy z Shopify w przesyłce,
-Delivery Note Series,Seria notatek dostawy,
-Import Sales Invoice from Shopify if Payment is marked,"Importuj fakturę sprzedaży z Shopify, jeśli płatność została zaznaczona",
-Sales Invoice Series,Seria faktur sprzedaży,
-Shopify Tax Account,Shopify Tax Account,
-Shopify Tax/Shipping Title,Kupuj podatek / tytuł dostawy,
-ERPNext Account,ERPNext Konto,
-Shopify Webhook Detail,Szczegółowe informacje o Shophook,
-Webhook ID,Identyfikator Webhooka,
-Tally Migration,Tally Migration,
-Master Data,Dane podstawowe,
-"Data exported from Tally that consists of the Chart of Accounts, Customers, Suppliers, Addresses, Items and UOMs","Dane wyeksportowane z Tally, które obejmują plan kont, klientów, dostawców, adresy, towary i jednostki miary",
-Is Master Data Processed,Czy przetwarzane są dane podstawowe,
-Is Master Data Imported,Czy importowane są dane podstawowe,
-Tally Creditors Account,Tally Credit Accounts,
-Creditors Account set in Tally,Konto wierzycieli ustawione w Tally,
-Tally Debtors Account,Rachunek Dłużników Tally,
-Debtors Account set in Tally,Konto dłużników ustawione w Tally,
-Tally Company,Firma Tally,
-Company Name as per Imported Tally Data,Nazwa firmy zgodnie z zaimportowanymi danymi Tally,
-Default UOM,Domyślna jednostka miary,
-UOM in case unspecified in imported data,JM w przypadku nieokreślonego w importowanych danych,
-ERPNext Company,ERPNext Company,
-Your Company set in ERPNext,Twoja firma ustawiona w ERPNext,
-Processed Files,Przetworzone pliki,
-Parties,Strony,
-UOMs,Jednostki miary,
-Vouchers,Kupony,
-Round Off Account,Konto kwot zaokrągleń,
-Day Book Data,Dane książki dziennej,
-Day Book Data exported from Tally that consists of all historic transactions,"Dane księgi dziennej wyeksportowane z Tally, które zawierają wszystkie historyczne transakcje",
-Is Day Book Data Processed,Czy przetwarzane są dane dzienników,
-Is Day Book Data Imported,Importowane są dane dzienników,
-Woocommerce Settings,Ustawienia Woocommerce,
-Enable Sync,Włącz synchronizację,
-Woocommerce Server URL,URL serwera Woocommerce,
-Secret,Sekret,
-API consumer key,Klucz konsumenta API,
-API consumer secret,Tajny klucz klienta API,
-Tax Account,Konto podatkowe,
-Freight and Forwarding Account,Konto spedycyjne i spedycyjne,
-Creation User,Użytkownik tworzenia,
-"The user that will be used to create Customers, Items and Sales Orders. This user should have the relevant permissions.","Użytkownik, który będzie używany do tworzenia klientów, towarów i zleceń sprzedaży. Ten użytkownik powinien mieć odpowiednie uprawnienia.",
-"This warehouse will be used to create Sales Orders. The fallback warehouse is ""Stores"".",Ten magazyn będzie używany do tworzenia zamówień sprzedaży. Magazyn zapasowy to „Sklepy”.,
-"The fallback series is ""SO-WOO-"".",Seria awaryjna to „SO-WOO-”.,
-This company will be used to create Sales Orders.,Ta firma będzie używana do tworzenia zamówień sprzedaży.,
-Delivery After (Days),Dostawa po (dni),
-This is the default offset (days) for the Delivery Date in Sales Orders. The fallback offset is 7 days from the order placement date.,Jest to domyślne przesunięcie (dni) dla daty dostawy w zamówieniach sprzedaży. Przesunięcie awaryjne wynosi 7 dni od daty złożenia zamówienia.,
-"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".",Jest to domyślna jednostka miary używana dla elementów i zamówień sprzedaży. Rezerwowym UOM jest „Nos”.,
-Endpoints,Punkty końcowe,
-Endpoint,Punkt końcowy,
-Antibiotic Name,Nazwa antybiotyku,
-Healthcare Administrator,Administrator Ochrony Zdrowia,
-Laboratory User,Użytkownik Laboratorium,
-Is Inpatient,Jest hospitalizowany,
-Default Duration (In Minutes),Domyślny czas trwania (w minutach),
-Body Part,Część ciała,
-Body Part Link,Link do części ciała,
-HLC-CPR-.YYYY.-,HLC-CPR-.RRRR.-,
-Procedure Template,Szablon procedury,
-Procedure Prescription,Procedura Recepta,
-Service Unit,Jednostka serwisowa,
-Consumables,Materiały eksploatacyjne,
-Consume Stock,Zużyj zapasy,
-Invoice Consumables Separately,Fakturuj oddzielnie materiały eksploatacyjne,
-Consumption Invoiced,Zużycie fakturowane,
-Consumable Total Amount,Łączna ilość materiałów eksploatacyjnych,
-Consumption Details,Szczegóły zużycia,
-Nursing User,Pielęgniarka,
-Clinical Procedure Item,Procedura postępowania klinicznego,
-Invoice Separately as Consumables,Faktura oddzielnie jako materiał eksploatacyjny,
-Transfer Qty,Przenieś ilość,
-Actual Qty (at source/target),Rzeczywista Ilość (u źródła/celu),
-Is Billable,Jest rozliczalny,
-Allow Stock Consumption,Zezwalaj na zużycie zapasów,
-Sample UOM,Przykładowa jednostka miary,
-Collection Details,Szczegóły kolekcji,
-Change In Item,Zmiana w pozycji,
-Codification Table,Tabela kodyfikacji,
-Complaints,Uskarżanie się,
-Dosage Strength,Siła dawkowania,
-Strength,Wytrzymałość,
-Drug Prescription,Na receptę,
-Drug Name / Description,Nazwa / opis leku,
-Dosage,Dawkowanie,
-Dosage by Time Interval,Dawkowanie według przedziału czasu,
-Interval,Interwał,
-Interval UOM,Interwał UOM,
-Hour,Godzina,
-Update Schedule,Zaktualizuj harmonogram,
-Exercise,Ćwiczenie,
-Difficulty Level,Poziom trudności,
-Counts Target,Liczy cel,
-Counts Completed,Liczenie zakończone,
-Assistance Level,Poziom pomocy,
-Active Assist,Aktywna pomoc,
-Exercise Name,Nazwa ćwiczenia,
-Body Parts,Części ciała,
-Exercise Instructions,Instrukcje do ćwiczeń,
-Exercise Video,Ćwiczenia wideo,
-Exercise Steps,Kroki ćwiczeń,
-Steps,Kroki,
-Steps Table,Tabela kroków,
-Exercise Type Step,Krok typu ćwiczenia,
-Max number of visit,Maksymalna liczba wizyt,
-Visited yet,Jeszcze odwiedziłem,
-Reference Appointments,Spotkania referencyjne,
-Valid till,Obowiązuje do,
-Fee Validity Reference,Odniesienie do ważności opłat,
-Basic Details,Podstawowe szczegóły,
-HLC-PRAC-.YYYY.-,HLC-PRAC-.YYYY.-,
-Mobile,mobilny,
-Phone (R),Telefon (R),
-Phone (Office),Telefon (Biuro),
-Employee and User Details,Dane pracownika i użytkownika,
-Hospital,Szpital,
-Appointments,Terminy,
-Practitioner Schedules,Harmonogramy praktyków,
-Charges,Opłaty,
-Out Patient Consulting Charge,Opłata za konsultacje z pacjentem zewnętrznym,
-Default Currency,Domyślna waluta,
-Healthcare Schedule Time Slot,Schemat czasu opieki zdrowotnej,
-Parent Service Unit,Jednostka usług dla rodziców,
-Service Unit Type,Rodzaj jednostki usługi,
-Allow Appointments,Zezwalaj na spotkania,
-Allow Overlap,Zezwalaj na Nakładanie,
-Inpatient Occupancy,Zajęcia stacjonarne,
-Occupancy Status,Status obłożenia,
-Vacant,Pusty,
-Occupied,Zajęty,
-Item Details,Szczegóły produktu,
-UOM Conversion in Hours,Konwersja UOM w godzinach,
-Rate / UOM,Rate / UOM,
-Change in Item,Zmień pozycję,
-Out Patient Settings,Out Ustawienia pacjenta,
-Patient Name By,Nazwisko pacjenta,
-Patient Name,Imię pacjenta,
-Link Customer to Patient,Połącz klienta z pacjentem,
-"If checked, a customer will be created, mapped to Patient.\nPatient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.","Jeśli zostanie zaznaczone, zostanie utworzony klient, który będzie mapowany na pacjenta. Dla tego klienta powstanie faktury pacjenta. Można również wybrać istniejącego klienta podczas tworzenia pacjenta.",
-Default Medical Code Standard,Domyślny standard kodu medycznego,
-Collect Fee for Patient Registration,Zbierz opłatę za rejestrację pacjenta,
-Checking this will create new Patients with a Disabled status by default and will only be enabled after invoicing the Registration Fee.,Zaznaczenie tej opcji spowoduje utworzenie nowych pacjentów ze statusem Wyłączony domyślnie i będzie włączone dopiero po zafakturowaniu Opłaty rejestracyjnej.,
-Registration Fee,Opłata za rejestrację,
-Automate Appointment Invoicing,Zautomatyzuj fakturowanie spotkań,
-Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Zarządzaj fakturą Powołania automatycznie przesyłaj i anuluj spotkanie z pacjentem,
-Enable Free Follow-ups,Włącz bezpłatne obserwacje,
-Number of Patient Encounters in Valid Days,Liczba spotkań pacjentów w ważne dni,
-The number of free follow ups (Patient Encounters in valid days) allowed,Dozwolona liczba bezpłatnych obserwacji (spotkań pacjentów w ważnych dniach),
-Valid Number of Days,Ważna liczba dni,
-Time period (Valid number of days) for free consultations,Okres (ważna liczba dni) na bezpłatne konsultacje,
-Default Healthcare Service Items,Domyślne pozycje usług opieki zdrowotnej,
-"You can configure default Items for billing consultation charges, procedure consumption items and inpatient visits","Można skonfigurować pozycje domyślne w celu rozliczenia opłat za konsultacje, pozycji dotyczących zużycia procedur i wizyt szpitalnych",
-Clinical Procedure Consumable Item,Procedura kliniczna Materiały eksploatacyjne,
-Default Accounts,Konta domyślne,
-Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,"Konta z domyślnymi dochodami, które mają być używane, jeśli nie są ustawione w Healthcare Practitioner, aby zarezerwować opłaty za spotkanie.",
-Default receivable accounts to be used to book Appointment charges.,"Domyślne konta należności, które mają być używane do księgowania opłat za spotkanie.",
-Out Patient SMS Alerts,Wypisuj alerty SMS dla pacjentów,
-Patient Registration,Rejestracja pacjenta,
-Registration Message,Wiadomość rejestracyjna,
-Confirmation Message,Wiadomość potwierdzająca,
-Avoid Confirmation,Unikaj Potwierdzenia,
-Do not confirm if appointment is created for the same day,"Nie potwierdzaj, czy spotkanie zostanie utworzone na ten sam dzień",
-Appointment Reminder,Przypomnienie o spotkaniu,
-Reminder Message,Komunikat Przypomnienia,
-Remind Before,Przypomnij wcześniej,
-Laboratory Settings,Ustawienia laboratoryjne,
-Create Lab Test(s) on Sales Invoice Submission,Utwórz testy laboratoryjne podczas przesyłania faktur sprzedaży,
-Checking this will create Lab Test(s) specified in the Sales Invoice on submission.,Zaznaczenie tego spowoduje utworzenie testów laboratoryjnych określonych na fakturze sprzedaży podczas przesyłania.,
-Create Sample Collection document for Lab Test,Utwórz dokument pobierania próbek do testu laboratoryjnego,
-Checking this will create a Sample Collection document  every time you create a Lab Test,"Zaznaczenie tego spowoduje utworzenie dokumentu pobierania próbek za każdym razem, gdy utworzysz test laboratoryjny",
-Employee name and designation in print,Nazwisko pracownika i oznaczenie w druku,
-Check this if you want the Name and Designation of the Employee associated with the User who submits the document to be printed in the Lab Test Report.,"Zaznacz tę opcję, jeśli chcesz, aby nazwa i oznaczenie pracownika skojarzone z użytkownikiem przesyłającym dokument zostały wydrukowane w raporcie z testu laboratoryjnego.",
-Do not print or email Lab Tests without Approval,Nie drukuj ani nie wysyłaj e-mailem testów laboratoryjnych bez zgody,
-Checking this will restrict printing and emailing of Lab Test documents unless they have the status as Approved.,"Zaznaczenie tego ograniczy drukowanie i wysyłanie pocztą elektroniczną dokumentów testów laboratoryjnych, chyba że mają one status Zatwierdzone.",
-Custom Signature in Print,Podpis niestandardowy w druku,
-Laboratory SMS Alerts,Laboratorium SMS Alerts,
-Result Printed Message,Wynik wydrukowany komunikat,
-Result Emailed Message,Wiadomość e-mail z wynikami,
-Check In,Zameldować się,
-Check Out,Sprawdzić,
-HLC-INP-.YYYY.-,HLC-INP-.YYYY.-,
-A Positive,Pozytywny,
-A Negative,Negatywny,
-AB Positive,AB Pozytywne,
-AB Negative,AB Negatywne,
-B Positive,B dodatni,
-B Negative,B Negatywne,
-O Positive,O pozytywne,
-O Negative,O negatywne,
-Date of birth,Data urodzenia,
-Admission Scheduled,Wstęp Zaplanowany,
-Discharge Scheduled,Rozładowanie Zaplanowane,
-Discharged,Rozładowany,
-Admission Schedule Date,Harmonogram przyjęcia,
-Admitted Datetime,Przyjęto Datetime,
-Expected Discharge,Oczekiwany zrzut,
-Discharge Date,Data rozładowania,
-Lab Prescription,Lekarz na receptę,
-Lab Test Name,Nazwa testu laboratoryjnego,
-Test Created,Utworzono test,
-Submitted Date,Zaakceptowana Data,
-Approved Date,Zatwierdzona data,
-Sample ID,Identyfikator wzorcowy,
-Lab Technician,Technik laboratoryjny,
-Report Preference,Preferencje raportu,
-Test Name,Nazwa testu,
-Test Template,Szablon testu,
-Test Group,Grupa testowa,
-Custom Result,Wynik niestandardowy,
-LabTest Approver,Przybliżenie LabTest,
-Add Test,Dodaj test,
-Normal Range,Normalny zakres,
-Result Format,Format wyników,
-Single,Pojedynczy,
-Compound,Złożony,
-Descriptive,Opisowy,
-Grouped,Zgrupowane,
-No Result,Brak wyników,
-This value is updated in the Default Sales Price List.,Ta wartość jest aktualizowana w Domyślnym Cenniku Sprzedaży.,
-Lab Routine,Lab Rutyna,
-Result Value,Wartość wyniku,
-Require Result Value,Wymagaj wartości,
-Normal Test Template,Normalny szablon testu,
-Patient Demographics,Dane demograficzne pacjenta,
-HLC-PAT-.YYYY.-,HLC-PAT-.YYYY.-,
-Middle Name (optional),Drugie imię (opcjonalnie),
-Inpatient Status,Status stacjonarny,
-"If ""Link Customer to Patient"" is checked in Healthcare Settings and an existing Customer is not selected then, a Customer will be created for this Patient for recording transactions in Accounts module.","Jeśli w Ustawieniach opieki zdrowotnej zaznaczono opcję „Połącz klienta z pacjentem”, a istniejący klient nie zostanie wybrany, zostanie utworzony klient dla tego pacjenta w celu rejestrowania transakcji w module kont.",
-Personal and Social History,Historia osobista i społeczna,
-Marital Status,Stan cywilny,
-Married,Żonaty / Zamężna,
-Divorced,Rozwiedziony,
-Widow,Wdowa,
-Patient Relation,Relacja pacjenta,
-"Allergies, Medical and Surgical History","Alergie, historia medyczna i chirurgiczna",
-Allergies,Alergie,
-Medication,Lek,
-Medical History,Historia medyczna,
-Surgical History,Historia chirurgiczna,
-Risk Factors,Czynniki ryzyka,
-Occupational Hazards and Environmental Factors,Zagrożenia zawodowe i czynniki środowiskowe,
-Other Risk Factors,Inne czynniki ryzyka,
-Patient Details,Szczegóły pacjenta,
-Additional information regarding the patient,Dodatkowe informacje dotyczące pacjenta,
-HLC-APP-.YYYY.-,HLC-APP-.YYYY.-,
-Patient Age,Wiek pacjenta,
-Get Prescribed Clinical Procedures,Uzyskaj przepisane procedury kliniczne,
-Therapy,Terapia,
-Get Prescribed Therapies,Uzyskaj przepisane terapie,
-Appointment Datetime,Data spotkania,
-Duration (In Minutes),Czas trwania (w minutach),
-Reference Sales Invoice,Referencyjna faktura sprzedaży,
-More Info,Więcej informacji,
-Referring Practitioner,Polecający praktykujący,
-Reminded,Przypomnij,
-HLC-PA-.YYYY.-,HLC-PA-.YYYY.-,
-Assessment Template,Szablon oceny,
-Assessment Datetime,Czas oceny,
-Assessment Description,Opis oceny,
-Assessment Sheet,Arkusz oceny,
-Total Score Obtained,Całkowity wynik uzyskany,
-Scale Min,Skala min,
-Scale Max,Skala Max,
-Patient Assessment Detail,Szczegóły oceny pacjenta,
-Assessment Parameter,Parametr oceny,
-Patient Assessment Parameter,Parametr oceny pacjenta,
-Patient Assessment Sheet,Arkusz oceny pacjenta,
-Patient Assessment Template,Szablon oceny pacjenta,
-Assessment Parameters,Parametry oceny,
-Parameters,Parametry,
-Assessment Scale,Skala oceny,
-Scale Minimum,Minimalna skala,
-Scale Maximum,Skala maksymalna,
-HLC-ENC-.YYYY.-,HLC-ENC-.YYYY.-,
-Encounter Date,Data spotkania,
-Encounter Time,Czas spotkania,
-Encounter Impression,Encounter Impression,
-Symptoms,Objawy,
-In print,W druku,
-Medical Coding,Kodowanie medyczne,
-Procedures,Procedury,
-Therapies,Terapie,
-Review Details,Szczegóły oceny,
-Patient Encounter Diagnosis,Diagnoza spotkania pacjenta,
-Patient Encounter Symptom,Objaw spotkania pacjenta,
-HLC-PMR-.YYYY.-,HLC-PMR-.YYYY.-,
-Attach Medical Record,Dołącz dokumentację medyczną,
-Reference DocType,Odniesienie do DocType,
-Spouse,Małżonka,
-Family,Rodzina,
-Schedule Details,Szczegóły harmonogramu,
-Schedule Name,Nazwa harmonogramu,
-Time Slots,Szczeliny czasowe,
-Practitioner Service Unit Schedule,Harmonogram jednostki służby zdrowia,
-Procedure Name,Nazwa procedury,
-Appointment Booked,Spotkanie zarezerwowane,
-Procedure Created,Procedura Utworzono,
-HLC-SC-.YYYY.-,HLC-SC-.RRRR.-,
-Collected By,Zbierane przez,
-Particulars,Szczegóły,
-Result Component,Komponent wyników,
-HLC-THP-.YYYY.-,HLC-THP-.YYYY.-,
-Therapy Plan Details,Szczegóły planu terapii,
-Total Sessions,Całkowita liczba sesji,
-Total Sessions Completed,Całkowita liczba ukończonych sesji,
-Therapy Plan Detail,Szczegóły planu terapii,
-No of Sessions,Liczba sesji,
-Sessions Completed,Sesje zakończone,
-Tele,Tele,
-Exercises,Ćwiczenia,
-Therapy For,Terapia dla,
-Add Exercises,Dodaj ćwiczenia,
-Body Temperature,Temperatura ciała,
-Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Obecność gorączki (temp.&gt; 38,5 ° C / 101,3 ° F lub trwała temperatura&gt; 38 ° C / 100,4 ° F)",
-Heart Rate / Pulse,Częstość tętna / impuls,
-Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Częstość tętna wynosi od 50 do 80 uderzeń na minutę.,
-Respiratory rate,Oddechowy,
-Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normalny zakres referencyjny dla dorosłych wynosi 16-20 oddech / minutę (RCP 2012),
-Tongue,Język,
-Coated,Pokryty,
-Very Coated,Bardzo powlekane,
-Normal,Normalna,
-Furry,Futrzany,
-Cuts,Cięcia,
-Abdomen,Brzuch,
-Bloated,Nadęty,
-Fluid,Płyn,
-Constipated,Mający zaparcie,
-Reflexes,Odruchy,
-Hyper,Hyper,
-Very Hyper,Bardzo Hyper,
-One Sided,Jednostronny,
-Blood Pressure (systolic),Ciśnienie krwi (skurczowe),
-Blood Pressure (diastolic),Ciśnienie krwi (rozkurczowe),
-Blood Pressure,Ciśnienie krwi,
-"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Normalne spoczynkowe ciśnienie krwi u dorosłych wynosi około 120 mmHg skurczowe, a rozkurczowe 80 mmHg, skrócone &quot;120/80 mmHg&quot;",
-Nutrition Values,Wartości odżywcze,
-Height (In Meter),Wysokość (w metrze),
-Weight (In Kilogram),Waga (w kilogramach),
-BMI,BMI,
-Hotel Room,Pokój hotelowy,
-Hotel Room Type,Rodzaj pokoju hotelowego,
-Capacity,Pojemność,
-Extra Bed Capacity,Wydajność dodatkowego łóżka,
-Hotel Manager,Kierownik hotelu,
-Hotel Room Amenity,Udogodnienia w pokoju hotelowym,
-Billable,Rozliczalny,
-Hotel Room Package,Pakiet hotelowy,
-Amenities,Udogodnienia,
-Hotel Room Pricing,Ceny pokoi w hotelu,
-Hotel Room Pricing Item,Cennik pokoi hotelowych,
-Hotel Room Pricing Package,Pakiet cen pokoi hotelowych,
-Hotel Room Reservation,Rezerwacja pokoju hotelowego,
-Guest Name,Imię gościa,
-Late Checkin,Późne zameldowanie,
-Booked,Zarezerwowane,
-Hotel Reservation User,Użytkownik rezerwacji hotelu,
-Hotel Room Reservation Item,Rezerwacja pokoju hotelowego,
-Hotel Settings,Ustawienia hotelu,
-Default Taxes and Charges,Domyślne podatków i opłat,
-Default Invoice Naming Series,Domyślna seria nazewnictwa faktur,
-Additional Salary,Dodatkowe wynagrodzenie,
-HR,HR,
-HR-ADS-.YY.-.MM.-,HR-ADS-.YY .-. MM.-,
-Salary Component,Wynagrodzenie Komponent,
-Overwrite Salary Structure Amount,Nadpisz ilość wynagrodzenia,
-Deduct Full Tax on Selected Payroll Date,Odliczenie pełnego podatku od wybranej daty płac,
-Payroll Date,Data płacy,
-Date on which this component is applied,Data zastosowania tego komponentu,
-Salary Slip,Pasek wynagrodzenia,
-Salary Component Type,Typ składnika wynagrodzenia,
-HR User,Kadry - użytkownik,
-Appointment Letter,List z terminem spotkania,
-Job Applicant,Aplikujący o pracę,
-Applicant Name,Imię Aplikanta,
-Appointment Date,Data spotkania,
-Appointment Letter Template,Szablon listu z terminami,
-Body,Ciało,
-Closing Notes,Uwagi końcowe,
-Appointment Letter content,Treść listu z terminem,
-Appraisal,Ocena,
-HR-APR-.YY.-.MM.,HR-APR-.YY.-.MM.,
-Appraisal Template,Szablon oceny,
-For Employee Name,Dla Imienia Pracownika,
-Goals,Cele,
-Total Score (Out of 5),Łączny wynik (w skali do 5),
-"Any other remarks, noteworthy effort that should go in the records.","Wszelkie inne uwagi, zauważyć, że powinien iść nakładu w ewidencji.",
-Appraisal Goal,Cel oceny,
-Key Responsibility Area,Kluczowy obszar obowiązków,
-Weightage (%),Waga/wiek (%),
-Score (0-5),Wynik (0-5),
-Score Earned,Ilość zdobytych punktów,
-Appraisal Template Title,Tytuł szablonu oceny,
-Appraisal Template Goal,Cel szablonu oceny,
-KRA,KRA,
-Key Performance Area,Kluczowy obszar wyników,
-HR-ATT-.YYYY.-,HR-ATT-.RRRR.-,
-On Leave,Na urlopie,
-Work From Home,Praca w domu,
-Leave Application,Wniosek o Nieobecność,
-Attendance Date,Data usługi,
-Attendance Request,Żądanie obecności,
-Late Entry,Późne wejście,
-Early Exit,Wczesne wyjście,
-Half Day Date,Pół Dzień Data,
-On Duty,Na służbie,
-Explanation,Wyjaśnienie,
-Compensatory Leave Request,Wniosek o urlop Wyrównawczy,
-Leave Allocation,Alokacja Nieobecności,
-Worked On Holiday,Pracowałem w wakacje,
-Work From Date,Praca od daty,
-Work End Date,Data zakończenia pracy,
-Email Sent To,Email wysłany do,
-Select Users,Wybierz użytkowników,
-Send Emails At,Wyślij pocztę elektroniczną w,
-Reminder,Przypomnienie,
-Daily Work Summary Group User,Codzienny użytkownik grupy roboczej,
-email,e-mail,
-Parent Department,Departament rodziców,
-Leave Block List,Lista Blokowanych Nieobecności,
-Days for which Holidays are blocked for this department.,Dni kiedy urlop jest zablokowany dla tego departamentu,
-Leave Approver,Zatwierdzający Nieobecność,
-Expense Approver,Osoba zatwierdzająca wydatki,
-Department Approver,Departament zatwierdzający,
-Approver,Osoba zatwierdzająca,
-Required Skills,Wymagane umiejętności,
-Skills,Umiejętności,
-Designation Skill,Umiejętność oznaczania,
-Skill,Umiejętność,
-Driver,Kierowca,
-HR-DRI-.YYYY.-,HR-DRI-.RRRR.-,
-Suspended,Zawieszony,
-Transporter,Transporter,
-Applicable for external driver,Dotyczy zewnętrznego sterownika,
-Cellphone Number,numer telefonu komórkowego,
-License Details,Szczegóły licencji,
-License Number,Numer licencji,
-Issuing Date,Data emisji,
-Driving License Categories,Kategorie prawa jazdy,
-Driving License Category,Kategoria prawa jazdy,
-Fleet Manager,Menedżer floty,
-Driver licence class,Klasa prawa jazdy,
-HR-EMP-,HR-EMP-,
-Employment Type,Typ zatrudnienia,
-Emergency Contact,Kontakt na wypadek nieszczęśliwych wypadków,
-Emergency Contact Name,kontakt do osoby w razie wypadku,
-Emergency Phone,Telefon bezpieczeństwa,
-ERPNext User,ERPNext Użytkownik,
-"System User (login) ID. If set, it will become default for all HR forms.","Użytkownik systemu (login) ID. Jeśli ustawiono, stanie się on domyślnym dla wszystkich formularzy HR",
-Create User Permission,Utwórz uprawnienia użytkownika,
-This will restrict user access to other employee records,To ograniczy dostęp użytkowników do innych rekordów pracowników,
-Joining Details,Łączenie szczegółów,
-Offer Date,Data oferty,
-Confirmation Date,Data potwierdzenia,
-Contract End Date,Data końcowa kontraktu,
-Notice (days),Wymówienie (dni),
-Date Of Retirement,Data przejścia na emeryturę,
-Department and Grade,Wydział i stopień,
-Reports to,Raporty do,
-Attendance and Leave Details,Frekwencja i szczegóły urlopu,
-Leave Policy,Polityka Nieobecności,
-Attendance Device ID (Biometric/RF tag ID),Identyfikator urządzenia obecności (identyfikator biometryczny / RF),
-Applicable Holiday List,Stosowna Lista Urlopów,
-Default Shift,Domyślne przesunięcie,
-Salary Details,Szczegóły wynagrodzeń,
-Salary Mode,Moduł Wynagrodzenia,
-Bank A/C No.,Numer rachunku bankowego,
-Health Insurance,Ubezpieczenie zdrowotne,
-Health Insurance Provider,Dostawca ubezpieczenia zdrowotnego,
-Health Insurance No,Numer ubezpieczenia zdrowotnego,
-Prefered Email,Zalecany email,
-Personal Email,Osobisty E-mail,
-Permanent Address Is,Stały adres to,
-Rented,Wynajęty,
-Owned,Zawłaszczony,
-Permanent Address,Stały adres,
-Prefered Contact Email,Preferowany kontakt e-mail,
-Company Email,Email do firmy,
-Provide Email Address registered in company,Podać adres e-mail zarejestrowany w firmie,
-Current Address Is,Obecny adres to,
-Current Address,Obecny adres,
-Personal Bio,Personal Bio,
-Bio / Cover Letter,Bio / List motywacyjny,
-Short biography for website and other publications.,Krótka notka na stronę i do innych publikacji,
-Passport Number,Numer Paszportu,
-Date of Issue,Data wydania,
-Place of Issue,Miejsce wydania,
-Widowed,Wdowiec / Wdowa,
-Family Background,Tło rodzinne,
-"Here you can maintain family details like name and occupation of parent, spouse and children",,
-Health Details,Szczegóły Zdrowia,
-"Here you can maintain height, weight, allergies, medical concerns etc","Tutaj wypełnij i przechowaj dane takie jak wzrost, waga, alergie, problemy medyczne itd",
-Educational Qualification,Kwalifikacje edukacyjne,
-Previous Work Experience,Poprzednie doświadczenie zawodowe,
-External Work History,Historia Zewnętrzna Pracy,
-History In Company,Historia Firmy,
-Internal Work History,Wewnętrzne Historia Pracuj,
-Resignation Letter Date,Data wypowiedzenia,
-Relieving Date,Data zwolnienia,
-Reason for Leaving,Powód odejścia,
-Leave Encashed?,"Jesteś pewien, że chcesz wyjść z Wykupinych?",
-Encashment Date,Data Inkaso,
-New Workplace,Nowe Miejsce Pracy,
-HR-EAD-.YYYY.-,HR-EAD-.RRRR.-,
-Returned Amount,Zwrócona kwota,
-Claimed,Roszczenie,
-Advance Account,Rachunek zaawansowany,
-Employee Attendance Tool,Narzędzie Frekwencji,
-Unmarked Attendance,Obecność nieoznaczona,
-Employees HTML,Pracownicy HTML,
-Marked Attendance,Zaznaczona Obecność,
-Marked Attendance HTML,Zaznaczona Obecność HTML,
-Employee Benefit Application,Świadczenie pracownicze,
-Max Benefits (Yearly),Maksymalne korzyści (rocznie),
-Remaining Benefits (Yearly),Pozostałe korzyści (rocznie),
-Payroll Period,Okres płacy,
-Benefits Applied,Korzyści zastosowane,
-Dispensed Amount (Pro-rated),Dawka dodana (zaszeregowana),
-Employee Benefit Application Detail,Szczegóły zastosowania świadczeń pracowniczych,
-Earning Component,Zarabianie na komponent,
-Pay Against Benefit Claim,Zapłać na poczet zasiłku,
-Max Benefit Amount,Kwota maksymalnego świadczenia,
-Employee Benefit Claim,Świadczenie pracownicze,
-Claim Date,Data roszczenia,
-Benefit Type and Amount,Rodzaj świadczenia i kwota,
-Claim Benefit For,Zasiłek roszczenia dla,
-Max Amount Eligible,Maksymalna kwota kwalifikująca się,
-Expense Proof,Dowód wydatków,
-Employee Boarding Activity,Działalność Boarding pracownika,
-Activity Name,Nazwa działania,
-Task Weight,Zadanie waga,
-Required for Employee Creation,Wymagany w przypadku tworzenia pracowników,
-Applicable in the case of Employee Onboarding,Ma zastosowanie w przypadku wprowadzenia pracownika na rynek,
-Employee Checkin,Checkin pracownika,
-Log Type,Typ dziennika,
-OUT,NA ZEWNĄTRZ,
-Location / Device ID,Lokalizacja / identyfikator urządzenia,
-Skip Auto Attendance,Pomiń automatyczne uczestnictwo,
-Shift Start,Shift Start,
-Shift End,Shift End,
-Shift Actual Start,Shift Actual Start,
-Shift Actual End,Shift Actual End,
-Employee Education,Wykształcenie pracownika,
-School/University,Szkoła/Uniwersytet,
-Graduate,Absolwent,
-Post Graduate,Podyplomowe,
-Under Graduate,Absolwent,
-Year of Passing,Mijający rok,
-Class / Percentage,,
-Major/Optional Subjects,Główne/Opcjonalne Tematy,
-Employee External Work History,Historia zatrudnienia pracownika poza firmą,
-Total Experience,Całkowita kwota wydatków,
-Default Leave Policy,Domyślna Polityka Nieobecności,
-Default Salary Structure,Domyślna struktura wynagrodzenia,
-Employee Group Table,Tabela grup pracowników,
-ERPNext User ID,ERPNext Identyfikator użytkownika,
-Employee Health Insurance,Ubezpieczenie zdrowotne pracownika,
-Health Insurance Name,Nazwa ubezpieczenia zdrowotnego,
-Employee Incentive,Zachęta dla pracowników,
-Incentive Amount,Kwota motywacyjna,
-Employee Internal Work History,Historia zatrudnienia pracownika w firmie,
-Employee Onboarding,Wprowadzanie pracowników,
-Notify users by email,Powiadom użytkowników pocztą e-mail,
-Employee Onboarding Template,Szablon do wprowadzania pracowników,
-Activities,Zajęcia,
-Employee Onboarding Activity,Aktywność pracownika na pokładzie,
-Employee Other Income,Inne dochody pracownika,
-Employee Promotion,Promocja pracowników,
-Promotion Date,Data promocji,
-Employee Promotion Details,Szczegóły promocji pracowników,
-Employee Promotion Detail,Szczegóły promocji pracowników,
-Employee Property History,Historia nieruchomości pracownika,
-Employee Separation,Separacja pracowników,
-Employee Separation Template,Szablon separacji pracowników,
-Exit Interview Summary,Wyjdź z podsumowania wywiadu,
-Employee Skill,Umiejętność pracownika,
-Proficiency,Biegłość,
-Evaluation Date,Data oceny,
-Employee Skill Map,Mapa umiejętności pracowników,
-Employee Skills,Umiejętności pracowników,
-Trainings,Szkolenia,
-Employee Tax Exemption Category,Kategoria zwolnienia z podatku dochodowego od pracowników,
-Max Exemption Amount,Maksymalna kwota zwolnienia,
-Employee Tax Exemption Declaration,Deklaracja zwolnienia z podatku od pracowników,
-Declarations,Deklaracje,
-Total Declared Amount,Całkowita zadeklarowana kwota,
-Total Exemption Amount,Całkowita kwota zwolnienia,
-Employee Tax Exemption Declaration Category,Kategoria deklaracji zwolnienia podatkowego dla pracowników,
-Exemption Sub Category,Kategoria zwolnienia,
-Exemption Category,Kategoria zwolnienia,
-Maximum Exempted Amount,Maksymalna kwota zwolniona,
-Declared Amount,Zadeklarowana kwota,
-Employee Tax Exemption Proof Submission,Świadectwo zwolnienia podatkowego dla pracowników,
-Submission Date,Termin składania,
-Tax Exemption Proofs,Dowody zwolnienia podatkowego,
-Total Actual Amount,Całkowita rzeczywista kwota,
-Employee Tax Exemption Proof Submission Detail,Szczegółowe informacje dotyczące złożenia zeznania podatkowego dla pracowników,
-Maximum Exemption Amount,Maksymalna kwota zwolnienia,
-Type of Proof,Rodzaj dowodu,
-Actual Amount,Rzeczywista kwota,
-Employee Tax Exemption Sub Category,Podkategoria zwolnień podatkowych dla pracowników,
-Tax Exemption Category,Kategoria zwolnienia podatkowego,
-Employee Training,Szkolenie pracowników,
-Training Date,Data szkolenia,
-Employee Transfer,Przeniesienie pracownika,
-Transfer Date,Data przeniesienia,
-Employee Transfer Details,Dane dotyczące przeniesienia pracownika,
-Employee Transfer Detail,Dane dotyczące przeniesienia pracownika,
-Re-allocate Leaves,Realokuj Nieobeności,
-Create New Employee Id,Utwórz nowy identyfikator pracownika,
-New Employee ID,Nowy identyfikator pracownika,
-Employee Transfer Property,Usługa przenoszenia pracowniczych,
-HR-EXP-.YYYY.-,HR-EXP-.RRRR.-,
-Expense Taxes and Charges,Podatki i opłaty z tytułu kosztów,
-Total Sanctioned Amount,Całkowita kwota uznań,
-Total Advance Amount,Łączna kwota zaliczki,
-Total Claimed Amount,Całkowita kwota roszczeń,
-Total Amount Reimbursed,Całkowitej kwoty zwrotów,
-Vehicle Log,pojazd Log,
-Employees Email Id,Email ID pracownika,
-More Details,Więcej szczegółów,
-Expense Claim Account,Konto Koszty Roszczenie,
-Expense Claim Advance,Advance Claim Advance,
-Unclaimed amount,Nie zgłoszona kwota,
-Expense Claim Detail,Szczegóły o zwrotach kosztów,
-Expense Date,Data wydatku,
-Expense Claim Type,Typ Zwrotu Kosztów,
-Holiday List Name,Nazwa dla Listy Świąt,
-Total Holidays,Suma dni świątecznych,
-Add Weekly Holidays,Dodaj cotygodniowe święta,
-Weekly Off,Tygodniowy wyłączony,
-Add to Holidays,Dodaj do świąt,
-Holidays,Wakacje,
-Clear Table,Wyczyść tabelę,
-HR Settings,Ustawienia HR,
-Employee Settings,Ustawienia pracownika,
-Retirement Age,Wiek emerytalny,
-Enter retirement age in years,Podaj wiek emerytalny w latach,
-Stop Birthday Reminders,Zatrzymaj przypomnienia o urodzinach,
-Expense Approver Mandatory In Expense Claim,Potwierdzenie wydatków Obowiązkowe w rachunku kosztów,
-Payroll Settings,Ustawienia Listy Płac,
-Leave,Pozostawiać,
-Max working hours against Timesheet,Maksymalny czas pracy przed grafiku,
-Include holidays in Total no. of Working Days,Dolicz święta do całkowitej liczby dni pracujących,
-"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Jeśli zaznaczone, Całkowita liczba Dni Roboczych obejmie święta, a to zmniejsza wartość Wynagrodzenie za dzień",
-"If checked, hides and disables Rounded Total field in Salary Slips","Jeśli zaznaczone, ukrywa i wyłącza pole Zaokrąglona suma w kuponach wynagrodzeń",
-The fraction of daily wages to be paid for half-day attendance,Część dziennego wynagrodzenia za obecność na pół dnia,
-Email Salary Slip to Employee,Email Wynagrodzenie Slip pracownikowi,
-Emails salary slip to employee based on preferred email selected in Employee,Emaile wynagrodzenia poślizgu pracownikowi na podstawie wybranego w korzystnej email Pracownika,
-Encrypt Salary Slips in Emails,Szyfruj poświadczenia wynagrodzenia w wiadomościach e-mail,
-"The salary slip emailed to the employee will be password protected, the password will be generated based on the password policy.","Ślad wynagrodzenia przesłany pocztą elektroniczną do pracownika będzie chroniony hasłem, hasło zostanie wygenerowane na podstawie polityki haseł.",
-Password Policy,Polityka haseł,
-<b>Example:</b> SAL-{first_name}-{date_of_birth.year} <br>This will generate a password like SAL-Jane-1972,<b>Przykład:</b> SAL- {first_name} - {date_of_birth.year} <br> Spowoduje to wygenerowanie hasła takiego jak SAL-Jane-1972,
-Leave Settings,Ustawienia Nieobecności,
-Leave Approval Notification Template,Pozostaw szablon powiadomienia o zatwierdzeniu,
-Leave Status Notification Template,Pozostaw szablon powiadomienia o statusie,
-Role Allowed to Create Backdated Leave Application,Rola dozwolona do utworzenia aplikacji urlopowej z datą wsteczną,
-Leave Approver Mandatory In Leave Application,Pozostaw zatwierdzającego obowiązkowo w aplikacji opuszczającej,
-Show Leaves Of All Department Members In Calendar,Pokaż Nieobecności Wszystkich Członków Działu w Kalendarzu,
-Auto Leave Encashment,Auto Leave Encashment,
-Hiring Settings,Ustawienia wynajmu,
-Check Vacancies On Job Offer Creation,Sprawdź oferty pracy w tworzeniu oferty pracy,
-Identification Document Type,Typ dokumentu tożsamości,
-Effective from,Obowiązuje od,
-Allow Tax Exemption,Zezwalaj na zwolnienie z podatku,
-"If enabled, Tax Exemption Declaration will be considered for income tax calculation.","Jeśli ta opcja jest włączona, deklaracja zwolnienia z podatku będzie brana pod uwagę przy obliczaniu podatku dochodowego.",
-Standard Tax Exemption Amount,Kwota zwolnienia z podatku standardowego,
-Taxable Salary Slabs,Podatki podlegające opodatkowaniu,
-Taxes and Charges on Income Tax,Podatki i opłaty od podatku dochodowego,
-Other Taxes and Charges,Inne podatki i opłaty,
-Income Tax Slab Other Charges,Płyta podatku dochodowego Inne opłaty,
-Min Taxable Income,Min. Dochód podlegający opodatkowaniu,
-Max Taxable Income,Maksymalny dochód podlegający opodatkowaniu,
-Applicant for a Job,Aplikant do Pracy,
-Accepted,Przyjęte,
-Job Opening,Otwarcie naboru na stanowisko,
-Cover Letter,List motywacyjny,
-Resume Attachment,W skrócie Załącznik,
-Job Applicant Source,Źródło wniosku o pracę,
-Applicant Email Address,Adres e-mail wnioskodawcy,
-Awaiting Response,Oczekuje na Odpowiedź,
-Job Offer Terms,Warunki oferty pracy,
-Select Terms and Conditions,Wybierz Regulamin,
-Printing Details,Szczegóły Wydruku,
-Job Offer Term,Okres oferty pracy,
-Offer Term,Oferta Term,
-Value / Description,Wartość / Opis,
-Description of a Job Opening,Opis Ogłoszenia o Pracę,
-Job Title,Nazwa stanowiska pracy,
-Staffing Plan,Plan zatrudnienia,
-Planned number of Positions,Planowana liczba pozycji,
-"Job profile, qualifications required etc.","Profil stanowiska pracy, wymagane kwalifikacje itp.",
-HR-LAL-.YYYY.-,HR-LAL-.RRRR.-,
-Allocation,Przydział,
-New Leaves Allocated,Nowe Nieobecności Zaalokowane,
-Add unused leaves from previous allocations,Dodaj niewykorzystane nieobecności z poprzednich alokacji,
-Unused leaves,Niewykorzystane Nieobecności,
-Total Leaves Allocated,Całkowita ilość przyznanych dni zwolnienia od pracy,
-Total Leaves Encashed,Total Leaves Encashed,
-Leave Period,Okres Nieobecności,
-Carry Forwarded Leaves,,
-Apply / Approve Leaves,Zastosuj / Zatwierdź Nieobecności,
-HR-LAP-.YYYY.-,HR-LAP-.YYYY.-,
-Leave Balance Before Application,Status Nieobecności przed Wnioskiem,
-Total Leave Days,Całkowita liczba Dni Nieobecności,
-Leave Approver Name,Nazwa Zatwierdzającego Nieobecność,
-Follow via Email,Odpowiedz za pomocą E-maila,
-Block Holidays on important days.,Blok Wakacje na ważne dni.,
-Leave Block List Name,Nazwa Listy Blokowanych Nieobecności,
-Applies to Company,Dotyczy Firmy,
-"If not checked, the list will have to be added to each Department where it has to be applied.","Jeśli nie jest zaznaczone, lista będzie musiała być dodana do każdego Działu, w którym ma zostać zastosowany.",
-Block Days,Zablokowany Dzień,
-Stop users from making Leave Applications on following days.,Zatrzymaj możliwość składania zwolnienia chorobowego użytkownikom w następujące dni.,
-Leave Block List Dates,Daty dopuszczenia na Liście Blokowanych Nieobecności,
-Allow Users,Zezwól Użytkownikom,
-Allow the following users to approve Leave Applications for block days.,,
-Leave Block List Allowed,Dopuszczone na Liście Blokowanych Nieobecności,
-Leave Block List Allow,Dopuść na Liście Blokowanych Nieobecności,
-Allow User,Zezwól Użytkownikowi,
-Leave Block List Date,Data dopuszczenia na Liście Blokowanych Nieobecności,
-Block Date,Zablokowana Data,
-Leave Control Panel,Panel do obsługi Nieobecności,
-Select Employees,Wybierz Pracownicy,
-Employment Type (optional),Rodzaj zatrudnienia (opcjonalnie),
-Branch (optional),Oddział (opcjonalnie),
-Department (optional),Dział (opcjonalnie),
-Designation (optional),Oznaczenie (opcjonalnie),
-Employee Grade (optional),Stopień pracownika (opcjonalnie),
-Employee (optional),Pracownik (opcjonalnie),
-Allocate Leaves,Przydziel liście,
-Carry Forward,Przeniesienie,
-Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,Proszę wybrać Przeniesienie jeżeli chcesz uwzględnić balans poprzedniego roku rozliczeniowego do tego roku rozliczeniowego,
-New Leaves Allocated (In Days),Nowe Nieobecności Zaalokowane (W Dniach),
-Allocate,Przydziel,
-Leave Balance,Pozostaw saldo,
-Encashable days,Szykowne dni,
-Encashment Amount,Kwota rabatu,
-Leave Ledger Entry,Pozostaw wpis księgi głównej,
-Transaction Name,Nazwa transakcji,
-Is Carry Forward,,
-Is Expired,Straciła ważność,
-Is Leave Without Pay,jest Urlopem Bezpłatnym,
-Holiday List for Optional Leave,Lista urlopowa dla Opcjonalnej Nieobecności,
-Leave Allocations,Alokacje Nieobecności,
-Leave Policy Details,Szczegóły Polityki Nieobecności,
-Leave Policy Detail,Szczegół Polityki Nieobecności,
-Annual Allocation,Roczna alokacja,
-Leave Type Name,Nazwa Typu Urlopu,
-Max Leaves Allowed,"Maksymalna, dozwolona liczba Nieobecności",
-Applicable After (Working Days),Dotyczy After (dni robocze),
-Maximum Continuous Days Applicable,Maksymalne ciągłe dni obowiązujące,
-Is Optional Leave,jest Nieobecnością Opcjonalną,
-Allow Negative Balance,Dozwolony ujemny bilans,
-Include holidays within leaves as leaves,Uwzględniaj święta w ramach Nieobecności,
-Is Compensatory,Jest kompensacyjny,
-Maximum Carry Forwarded Leaves,Maksymalna liczba przeniesionych liści,
-Expire Carry Forwarded Leaves (Days),Wygasają przenoszenie przekazanych liści (dni),
-Calculated in days,Obliczany w dniach,
-Encashment,Napad,
-Allow Encashment,Zezwól na Osadzanie,
-Encashment Threshold Days,Progi prolongaty,
-Earned Leave,Urlop w ramach nagrody,
-Is Earned Leave,jest Urlopem w ramach Nagrody,
-Earned Leave Frequency,Częstotliwość Urlopu w ramach nagrody,
-Rounding,Zaokrąglanie,
-Payroll Employee Detail,Szczegóły dotyczące kadry płacowej,
-Payroll Frequency,Częstotliwość Płace,
-Fortnightly,Dwutygodniowy,
-Bimonthly,Dwumiesięczny,
-Employees,Pracowników,
-Number Of Employees,Liczba pracowników,
-Employee Details,,
-Validate Attendance,Zweryfikuj Frekfencję,
-Salary Slip Based on Timesheet,Slip Wynagrodzenie podstawie grafiku,
-Select Payroll Period,Wybierz Okres Payroll,
-Deduct Tax For Unclaimed Employee Benefits,Odliczanie podatku za nieodebrane świadczenia pracownicze,
-Deduct Tax For Unsubmitted Tax Exemption Proof,Odliczanie podatku za nieprzedstawiony dowód zwolnienia podatkowego,
-Select Payment Account to make Bank Entry,Wybierz Konto Płatność aby bankowego Entry,
-Salary Slips Created,Utworzono zarobki,
-Salary Slips Submitted,Przesłane wynagrodzenie,
-Payroll Periods,Okresy płac,
-Payroll Period Date,Okres listy płac,
-Purpose of Travel,Cel podróży,
-Retention Bonus,Premia z zatrzymania,
-Bonus Payment Date,Data wypłaty bonusu,
-Bonus Amount,Kwota Bonusu,
-Abbr,Skrót,
-Depends on Payment Days,Zależy od dni płatności,
-Is Tax Applicable,Podatek obowiązuje,
-Variable Based On Taxable Salary,Zmienna oparta na podlegającym opodatkowaniu wynagrodzeniu,
-Exempted from Income Tax,Zwolnione z podatku dochodowego,
-Round to the Nearest Integer,Zaokrąglij do najbliższej liczby całkowitej,
-Statistical Component,Składnik statystyczny,
-"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Jeśli zostanie wybrana, wartość określona lub obliczona w tym składniku nie przyczyni się do zarobków ani odliczeń. Jednak wartością tę można odwoływać się do innych składników, które można dodawać lub potrącać.",
-Do Not Include in Total,Nie uwzględniaj w sumie,
-Flexible Benefits,Elastyczne korzyści,
-Is Flexible Benefit,Elastyczna korzyść,
-Max Benefit Amount (Yearly),Kwota maksymalnego świadczenia (rocznie),
-Only Tax Impact (Cannot Claim But Part of Taxable Income),Tylko wpływ podatkowy (nie można domagać się części dochodu podlegającego opodatkowaniu),
-Create Separate Payment Entry Against Benefit Claim,Utwórz oddzielne zgłoszenie wpłaty na poczet roszczenia o zasiłek,
-Condition and Formula,Stan i wzór,
-Amount based on formula,Kwota wg wzoru,
-Formula,Formuła,
-Salary Detail,Wynagrodzenie Szczegóły,
-Component,Składnik,
-Do not include in total,Nie obejmują łącznie,
-Default Amount,Domyślnie Kwota,
-Additional Amount,Dodatkowa ilość,
-Tax on flexible benefit,Podatek od elastycznej korzyści,
-Tax on additional salary,Podatek od dodatkowego wynagrodzenia,
-Salary Structure,Struktura Wynagrodzenia,
-Working Days,Dni robocze,
-Salary Slip Timesheet,Slip Wynagrodzenie grafiku,
-Total Working Hours,Całkowita liczba godzin pracy,
-Hour Rate,Stawka godzinowa,
-Bank Account No.,Nr konta bankowego,
-Earning & Deduction,Dochód i Odliczenie,
-Earnings,Dochody,
-Deductions,Odliczenia,
-Loan repayment,Spłata pożyczki,
-Employee Loan,pracownik Kredyt,
-Total Principal Amount,Łączna kwota główna,
-Total Interest Amount,Łączna kwota odsetek,
-Total Loan Repayment,Suma spłaty kredytu,
-net pay info,Informacje o wynagrodzeniu netto,
-Gross Pay - Total Deduction - Loan Repayment,Gross Pay - Razem Odliczenie - Spłata kredytu,
-Total in words,Ogółem słownie,
-Net Pay (in words) will be visible once you save the Salary Slip.,Wynagrodzenie netto (słownie) będzie widoczna po zapisaniu na Liście Płac.,
-Salary Component for timesheet based payroll.,Składnik wynagrodzenia za płac opartego grafik.,
-Leave Encashment Amount Per Day,Zostaw kwotę za dzieło na dzień,
-Max Benefits (Amount),Maksymalne korzyści (kwota),
-Salary breakup based on Earning and Deduction.,Średnie wynagrodzenie w oparciu o zarobki i odliczenia,
-Total Earning,Całkowita kwota zarobku,
-Salary Structure Assignment,Przydział struktury wynagrodzeń,
-Shift Assignment,Przydział Shift,
-Shift Type,Typ zmiany,
-Shift Request,Żądanie zmiany,
-Enable Auto Attendance,Włącz automatyczne uczestnictwo,
-Mark attendance based on 'Employee Checkin' for Employees assigned to this shift.,Oznacz obecność na podstawie „Checkin pracownika” dla pracowników przypisanych do tej zmiany.,
-Auto Attendance Settings,Ustawienia automatycznej obecności,
-Determine Check-in and Check-out,Określ odprawę i wymeldowanie,
-Alternating entries as IN and OUT during the same shift,Naprzemienne wpisy jako IN i OUT podczas tej samej zmiany,
-Strictly based on Log Type in Employee Checkin,Ściśle na podstawie typu dziennika w Checkin pracownika,
-Working Hours Calculation Based On,Obliczanie godzin pracy na podstawie,
-First Check-in and Last Check-out,Pierwsze zameldowanie i ostatnie wymeldowanie,
-Every Valid Check-in and Check-out,Każde ważne zameldowanie i wymeldowanie,
-Begin check-in before shift start time (in minutes),Rozpocznij odprawę przed czasem rozpoczęcia zmiany (w minutach),
-The time before the shift start time during which Employee Check-in is considered for attendance.,"Czas przed rozpoczęciem zmiany, podczas którego odprawa pracownicza jest brana pod uwagę przy uczestnictwie.",
-Allow check-out after shift end time (in minutes),Zezwól na wymeldowanie po zakończeniu czasu zmiany (w minutach),
-Time after the end of shift during which check-out is considered for attendance.,"Czas po zakończeniu zmiany, w trakcie którego wymeldowanie jest brane pod uwagę.",
-Working Hours Threshold for Half Day,Próg godzin pracy na pół dnia,
-Working hours below which Half Day is marked. (Zero to disable),"Godziny pracy, poniżej których zaznaczono pół dnia. (Zero, aby wyłączyć)",
-Working Hours Threshold for Absent,Próg godzin pracy dla nieobecności,
-Working hours below which Absent is marked. (Zero to disable),"Godziny pracy poniżej których nieobecność jest zaznaczona. (Zero, aby wyłączyć)",
-Process Attendance After,Uczestnictwo w procesie po,
-Attendance will be marked automatically only after this date.,Obecność zostanie oznaczona automatycznie dopiero po tej dacie.,
-Last Sync of Checkin,Ostatnia synchronizacja odprawy,
-Last Known Successful Sync of Employee Checkin. Reset this only if you are sure that all Logs are synced from all the locations. Please don't modify this if you are unsure.,"Ostatnia znana udana synchronizacja odprawy pracownika. Zresetuj to tylko wtedy, gdy masz pewność, że wszystkie dzienniki są synchronizowane ze wszystkich lokalizacji. Nie zmieniaj tego, jeśli nie jesteś pewien.",
-Grace Period Settings For Auto Attendance,Ustawienia okresu Grace dla automatycznej obecności,
-Enable Entry Grace Period,Włącz okres ważności wpisu,
-Late Entry Grace Period,Okres późnego wejścia,
-The time after the shift start time when check-in is considered as late (in minutes).,"Czas po godzinie rozpoczęcia zmiany, gdy odprawa jest uważana za późną (w minutach).",
-Enable Exit Grace Period,Włącz okres wyjścia Grace,
-Early Exit Grace Period,Wczesny okres wyjścia z inwestycji,
-The time before the shift end time when check-out is considered as early (in minutes).,"Czas przed czasem zakończenia zmiany, gdy wymeldowanie jest uważane za wczesne (w minutach).",
-Skill Name,Nazwa umiejętności,
-Staffing Plan Details,Szczegółowy plan zatrudnienia,
-Staffing Plan Detail,Szczegółowy plan zatrudnienia,
-Total Estimated Budget,Całkowity szacunkowy budżet,
-Vacancies,Wakaty,
-Estimated Cost Per Position,Szacowany koszt na stanowisko,
-Total Estimated Cost,Całkowity szacunkowy koszt,
-Current Count,Bieżąca liczba,
-Current Openings,Aktualne otwarcia,
-Number Of Positions,Liczba pozycji,
-Taxable Salary Slab,Podatki podlegające opodatkowaniu,
-From Amount,Od kwoty,
-To Amount,Do kwoty,
-Percent Deduction,Odliczenie procentowe,
-Training Program,Program treningowy,
-Event Status,zdarzenia,
-Has Certificate,Ma certyfikat,
-Seminar,Seminarium,
-Theory,Teoria,
-Workshop,Warsztat,
-Conference,Konferencja,
-Exam,Egzamin,
-Internet,Internet,
-Self-Study,Samokształcenie,
-Advance,Zaliczka,
-Trainer Name,Nazwa Trainer,
-Trainer Email,Trener email,
-Attendees,Uczestnicy,
-Employee Emails,E-maile z pracownikami,
-Training Event Employee,Training Event urzędnik,
-Invited,Zaproszony,
-Feedback Submitted,Zgłoszenie Zgłoszony,
-Optional,Opcjonalny,
-Training Result Employee,Wynik szkolenia pracowników,
-Travel Itinerary,Plan podróży,
-Travel From,Podróżuj z,
-Travel To,Podróż do,
-Mode of Travel,Tryb podróży,
-Flight,Lot,
-Train,Pociąg,
-Taxi,Taxi,
-Rented Car,Wynajęty samochód,
-Meal Preference,Preferencje Posiłków,
-Vegetarian,Wegetariański,
-Non-Vegetarian,Nie wegetarianskie,
-Gluten Free,Bezglutenowe,
-Non Diary,Non Diary,
-Travel Advance Required,Wymagane wcześniejsze podróżowanie,
-Departure Datetime,Data wyjazdu Datetime,
-Arrival Datetime,Przybycie Datetime,
-Lodging Required,Wymagane zakwaterowanie,
-Preferred Area for Lodging,Preferowany obszar zakwaterowania,
-Check-in Date,Sprawdź w terminie,
-Check-out Date,Sprawdź datę,
-Travel Request,Wniosek o podróż,
-Travel Type,Rodzaj podróży,
-Domestic,Krajowy,
-International,Międzynarodowy,
-Travel Funding,Finansowanie podróży,
-Require Full Funding,Wymagaj pełnego finansowania,
-Fully Sponsored,W pełni sponsorowane,
-"Partially Sponsored, Require Partial Funding","Częściowo sponsorowane, wymagające częściowego finansowania",
-Copy of Invitation/Announcement,Kopia zaproszenia / ogłoszenia,
-"Details of Sponsor (Name, Location)","Dane sponsora (nazwa, lokalizacja)",
-Identification Document Number,Numer identyfikacyjny dokumentu,
-Any other details,Wszelkie inne szczegóły,
-Costing Details,Szczegóły dotyczące kalkulacji kosztów,
-Costing,Zestawienie kosztów,
-Event Details,Szczegóły wydarzenia,
-Name of Organizer,Nazwa organizatora,
-Address of Organizer,Adres Organizatora,
-Travel Request Costing,Koszt wniosku podróży,
-Expense Type,Typ wydatków,
-Sponsored Amount,Sponsorowana kwota,
-Funded Amount,Kwota dofinansowania,
-Upload Attendance,Wyślij obecność,
-Attendance From Date,Obecność od Daty,
-Attendance To Date,Obecność do Daty,
-Get Template,Pobierz szablon,
-Import Attendance,Importuj Frekwencję,
-Upload HTML,Wyślij HTML,
-Vehicle,Pojazd,
-License Plate,Tablica rejestracyjna,
-Odometer Value (Last),Drogomierz Wartość (Ostatni),
-Acquisition Date,Data nabycia,
-Chassis No,Podwozie Nie,
-Vehicle Value,Wartość pojazdu,
-Insurance Details,Szczegóły ubezpieczenia,
-Insurance Company,Firma ubezpieczeniowa,
-Policy No,Polityka nr,
-Additional Details,Dodatkowe Szczegóły,
-Fuel Type,Typ paliwa,
-Petrol,Benzyna,
-Diesel,Diesel,
-Natural Gas,Gazu ziemnego,
-Electric,Elektryczny,
-Fuel UOM,Jednostka miary paliwa,
-Last Carbon Check,Ostatni Carbon Sprawdź,
-Wheels,Koła,
-Doors,drzwi,
-HR-VLOG-.YYYY.-,HR-VLOG-.YYYY.-,
-Odometer Reading,Stan licznika,
-Current Odometer value ,Aktualna wartość licznika przebiegu,
-last Odometer Value ,ostatnia wartość licznika przebiegu,
-Refuelling Details,Szczegóły tankowania,
-Invoice Ref,faktura Ref,
-Service Details,Szczegóły usługi,
-Service Detail,Szczegóły usługi,
-Vehicle Service,Obsługa pojazdu,
-Service Item,service Element,
-Brake Oil,Olej hamulcowy,
-Brake Pad,Klocek hamulcowy,
-Clutch Plate,sprzęgło,
-Engine Oil,Olej silnikowy,
-Oil Change,Wymiana oleju,
-Inspection,Kontrola,
-Mileage,Przebieg,
-Hub Tracked Item,Hub Tracked Item,
-Hub Node,Hub Węzeł,
-Image List,Lista obrazów,
-Item Manager,Pozycja menedżera,
-Hub User,Użytkownik centrum,
-Hub Password,Hasło koncentratora,
-Hub Users,Użytkownicy centrum,
-Marketplace Settings,Ustawienia Marketplace,
-Disable Marketplace,Wyłącz Marketplace,
-Marketplace URL (to hide and update label),Adres URL rynku (aby ukryć i zaktualizować etykietę),
-Registered,Zarejestrowany,
-Sync in Progress,Synchronizacja w toku,
-Hub Seller Name,Nazwa sprzedawcy Hub,
-Custom Data,Dane niestandardowe,
-Member,Członek,
-Partially Disbursed,częściowo wypłacona,
-Loan Closure Requested,Zażądano zamknięcia pożyczki,
-Repay From Salary,Spłaty z pensji,
-Loan Details,pożyczka Szczegóły,
-Loan Type,Rodzaj kredytu,
-Loan Amount,Kwota kredytu,
-Is Secured Loan,Jest zabezpieczona pożyczka,
-Rate of Interest (%) / Year,Stopa procentowa (% / rok),
-Disbursement Date,wypłata Data,
-Disbursed Amount,Kwota wypłacona,
-Is Term Loan,Jest pożyczką terminową,
-Repayment Method,Sposób spłaty,
-Repay Fixed Amount per Period,Spłacić ustaloną kwotę za okres,
-Repay Over Number of Periods,Spłaty przez liczbę okresów,
-Repayment Period in Months,Spłata Okres w miesiącach,
-Monthly Repayment Amount,Miesięczna kwota spłaty,
-Repayment Start Date,Data rozpoczęcia spłaty,
-Loan Security Details,Szczegóły bezpieczeństwa pożyczki,
-Maximum Loan Value,Maksymalna wartość pożyczki,
-Account Info,Informacje o koncie,
-Loan Account,Konto kredytowe,
-Interest Income Account,Konto przychodów odsetkowych,
-Penalty Income Account,Rachunek dochodów z kar,
-Repayment Schedule,Harmonogram spłaty,
-Total Payable Amount,Całkowita należna kwota,
-Total Principal Paid,Łącznie wypłacone główne zlecenie,
-Total Interest Payable,Razem odsetki płatne,
-Total Amount Paid,Łączna kwota zapłacona,
-Loan Manager,Menedżer pożyczek,
-Loan Info,pożyczka Info,
-Rate of Interest,Stopa procentowa,
-Proposed Pledges,Proponowane zobowiązania,
-Maximum Loan Amount,Maksymalna kwota kredytu,
-Repayment Info,Informacje spłata,
-Total Payable Interest,Całkowita zapłata odsetek,
-Against Loan ,Przed pożyczką,
-Loan Interest Accrual,Narosłe odsetki od pożyczki,
-Amounts,Kwoty,
-Pending Principal Amount,Oczekująca kwota główna,
-Payable Principal Amount,Kwota główna do zapłaty,
-Paid Principal Amount,Zapłacona kwota główna,
-Paid Interest Amount,Kwota zapłaconych odsetek,
-Process Loan Interest Accrual,Przetwarzanie naliczonych odsetek od kredytu,
-Repayment Schedule Name,Nazwa harmonogramu spłaty,
-Regular Payment,Regularna płatność,
-Loan Closure,Zamknięcie pożyczki,
-Payment Details,Szczegóły płatności,
-Interest Payable,Odsetki płatne,
-Amount Paid,Kwota zapłacona,
-Principal Amount Paid,Kwota główna wypłacona,
-Repayment Details,Szczegóły spłaty,
-Loan Repayment Detail,Szczegóły spłaty pożyczki,
-Loan Security Name,Nazwa zabezpieczenia pożyczki,
-Unit Of Measure,Jednostka miary,
-Loan Security Code,Kod bezpieczeństwa pożyczki,
-Loan Security Type,Rodzaj zabezpieczenia pożyczki,
-Haircut %,Strzyżenie%,
-Loan  Details,Szczegóły pożyczki,
-Unpledged,Niepowiązane,
-Pledged,Obiecał,
-Partially Pledged,Częściowo obiecane,
-Securities,Papiery wartościowe,
-Total Security Value,Całkowita wartość bezpieczeństwa,
-Loan Security Shortfall,Niedobór bezpieczeństwa pożyczki,
-Loan ,Pożyczka,
-Shortfall Time,Czas niedoboru,
-America/New_York,America / New_York,
-Shortfall Amount,Kwota niedoboru,
-Security Value ,Wartość bezpieczeństwa,
-Process Loan Security Shortfall,Niedobór bezpieczeństwa pożyczki procesowej,
-Loan To Value Ratio,Wskaźnik pożyczki do wartości,
-Unpledge Time,Unpledge Time,
-Loan Name,pożyczka Nazwa,
-Rate of Interest (%) Yearly,Stopa procentowa (%) Roczne,
-Penalty Interest Rate (%) Per Day,Kara odsetkowa (%) dziennie,
-Penalty Interest Rate is levied on the pending interest amount on a daily basis in case of delayed repayment ,Kara odsetkowa naliczana jest codziennie od oczekującej kwoty odsetek w przypadku opóźnionej spłaty,
-Grace Period in Days,Okres karencji w dniach,
-No. of days from due date until which penalty won't be charged in case of delay in loan repayment,"Liczba dni od daty wymagalności, do której kara nie będzie naliczana w przypadku opóźnienia w spłacie kredytu",
-Pledge,Zastaw,
-Post Haircut Amount,Kwota po ostrzyżeniu,
-Process Type,Typ procesu,
-Update Time,Czas aktualizacji,
-Proposed Pledge,Proponowane zobowiązanie,
-Total Payment,Całkowita płatność,
-Balance Loan Amount,Kwota salda kredytu,
-Is Accrued,Jest naliczony,
-Salary Slip Loan,Salary Slip Loan,
-Loan Repayment Entry,Wpis spłaty kredytu,
-Sanctioned Loan Amount,Kwota udzielonej sankcji,
-Sanctioned Amount Limit,Sankcjonowany limit kwoty,
-Unpledge,Unpledge,
-Haircut,Ostrzyżenie,
-MAT-MSH-.YYYY.-,MAT-MSH-.YYYY.-,
-Generate Schedule,Utwórz Harmonogram,
-Schedules,Harmonogramy,
-Maintenance Schedule Detail,Szczegóły Planu Konserwacji,
-Scheduled Date,Zaplanowana Data,
-Actual Date,Rzeczywista Data,
-Maintenance Schedule Item,Przedmiot Planu Konserwacji,
-Random,Losowy,
-No of Visits,Numer wizyt,
-MAT-MVS-.YYYY.-,MAT-MVS-.YYYY.-,
-Maintenance Date,Data Konserwacji,
-Maintenance Time,Czas Konserwacji,
-Completion Status,Status ukończenia,
-Partially Completed,Częściowo Ukończony,
-Fully Completed,Całkowicie ukończono,
-Unscheduled,Nieplanowany,
-Breakdown,Rozkład,
-Purposes,Cele,
-Customer Feedback,Informacja zwrotna Klienta,
-Maintenance Visit Purpose,Cel Wizyty Konserwacji,
-Work Done,Praca wykonana,
-Against Document No,,
-Against Document Detail No,,
-MFG-BLR-.YYYY.-,MFG-BLR-.RRRR.-,
-Order Type,Typ zamówienia,
-Blanket Order Item,Koc Zamówienie przedmiotu,
-Ordered Quantity,Zamówiona Ilość,
-Item to be manufactured or repacked,"Produkt, który ma zostać wyprodukowany lub przepakowany",
-Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Ilość produktu otrzymanego po produkcji / przepakowaniu z podanych ilości surowców,
-Set rate of sub-assembly item based on BOM,Ustaw stawkę pozycji podzakresu na podstawie BOM,
-Allow Alternative Item,Zezwalaj na alternatywną pozycję,
-Item UOM,Jednostka miary produktu,
-Conversion Rate,Współczynnik konwersji,
-Rate Of Materials Based On,Stawka Materiałów Wzorowana na,
-With Operations,Wraz z działaniami,
-Manage cost of operations,Zarządzaj kosztami działań,
-Transfer Material Against,Materiał transferowy przeciwko,
-Routing,Routing,
-Materials,Materiały,
-Quality Inspection Required,Wymagana kontrola jakości,
-Quality Inspection Template,Szablon kontroli jakości,
-Scrap,Skrawek,
-Scrap Items,złom przedmioty,
-Operating Cost,Koszty Operacyjne,
-Raw Material Cost,Koszt surowców,
-Scrap Material Cost,Złom Materiał Koszt,
-Operating Cost (Company Currency),Koszty operacyjne (Spółka waluty),
-Raw Material Cost (Company Currency),Koszt surowców (waluta spółki),
-Scrap Material Cost(Company Currency),Złom koszt materiału (Spółka waluty),
-Total Cost,Koszt całkowity,
-Total Cost (Company Currency),Koszt całkowity (waluta firmy),
-Materials Required (Exploded),Materiał Wymaga (Rozdzielony),
-Exploded Items,Przedmioty wybuchowe,
-Show in Website,Pokaż w witrynie,
-Item Image (if not slideshow),Element Obrazek (jeśli nie slideshow),
-Thumbnail,Miniaturka,
-Website Specifications,Specyfikacja strony WWW,
-Show Items,jasnowidze,
-Show Operations,Pokaż Operations,
-Website Description,Opis strony WWW,
-BOM Explosion Item,,
-Qty Consumed Per Unit,Ilość skonsumowana na Jednostkę,
-Include Item In Manufacturing,Dołącz przedmiot do produkcji,
-BOM Item,,
-Item operation,Obsługa przedmiotu,
-Rate & Amount,Stawka i kwota,
-Basic Rate (Company Currency),Podstawowy wskaźnik (Waluta Firmy),
-Scrap %,,
-Original Item,Oryginalna pozycja,
-BOM Operation,BOM Operacja,
-Operation Time ,Czas operacji,
-In minutes,W minutach,
-Batch Size,Wielkość partii,
-Base Hour Rate(Company Currency),Baza Hour Rate (Spółka waluty),
-Operating Cost(Company Currency),Koszty operacyjne (Spółka waluty),
-BOM Scrap Item,BOM Złom Item,
-Basic Amount (Company Currency),Kwota podstawowa (Spółka waluty),
-BOM Update Tool,Narzędzie aktualizacji BOM,
-"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.\nIt also updates latest price in all the BOMs.","Zastąp wymień płytę BOM we wszystkich pozostałych zestawieniach, w których jest używany. Zastąpi stary link BOM, aktualizuje koszt i zregeneruje tabelę &quot;BOM Explosion Item&quot; w nowym zestawieniu firm. Uaktualnia także najnowszą cenę we wszystkich materiałach.",
-Replace BOM,Wymień moduł,
-Current BOM,Obecny BOM,
-The BOM which will be replaced,BOM zostanie zastąpiony,
-The new BOM after replacement,Nowy BOM po wymianie,
-Replace,Zamień,
-Update latest price in all BOMs,Zaktualizuj ostatnią cenę we wszystkich biuletynach,
-BOM Website Item,BOM Website Element,
-BOM Website Operation,BOM Operacja WWW,
-Operation Time,Czas operacji,
-PO-JOB.#####,PO-JOB. #####,
-Timing Detail,Szczegóły dotyczące czasu,
-Time Logs,Logi czasu,
-Total Time in Mins,Całkowity czas w minutach,
-Operation ID,Identyfikator operacji,
-Transferred Qty,Przeniesione ilości,
-Job Started,Rozpoczęto pracę,
-Started Time,Rozpoczęty czas,
-Current Time,Obecny czas,
-Job Card Item,Element karty pracy,
-Job Card Time Log,Dziennik czasu pracy karty,
-Time In Mins,Czas w minutach,
-Completed Qty,Ukończona wartość,
-Manufacturing Settings,Ustawienia produkcyjne,
-Raw Materials Consumption,Zużycie surowców,
-Allow Multiple Material Consumption,Zezwalaj na wielokrotne zużycie materiałów,
-Backflush Raw Materials Based On,Płukanie surowce na podstawie,
-Material Transferred for Manufacture,Materiał Przeniesiony do Produkcji,
-Capacity Planning,Planowanie Pojemności,
-Disable Capacity Planning,Wyłącz planowanie wydajności,
-Allow Overtime,Pozwól na Nadgodziny,
-Allow Production on Holidays,Pozwól Produkcja na święta,
-Capacity Planning For (Days),Planowanie Pojemności Dla (dni),
-Default Warehouses for Production,Domyślne magazyny do produkcji,
-Default Work In Progress Warehouse,Domyślnie Work In Progress Warehouse,
-Default Finished Goods Warehouse,Magazyn wyrobów gotowych domyślne,
-Default Scrap Warehouse,Domyślny magazyn złomu,
-Overproduction Percentage For Sales Order,Procent nadprodukcji dla zamówienia sprzedaży,
-Overproduction Percentage For Work Order,Nadwyżka produkcyjna Procent zamówienia na pracę,
-Other Settings,Inne ustawienia,
-Update BOM Cost Automatically,Zaktualizuj automatycznie koszt BOM,
-Material Request Plan Item,Material Request Plan Item,
-Material Request Type,Typ zamówienia produktu,
-Material Issue,Wydanie materiałów,
-Customer Provided,Dostarczony Klient,
-Minimum Order Quantity,Minimalna ilość zamówienia,
-Default Workstation,Domyślne miejsce pracy,
-Production Plan,Plan produkcji,
-MFG-PP-.YYYY.-,MFG-PP-.RRRR.-,
-Get Items From,Pobierz zawartość z,
-Get Sales Orders,Pobierz zamówienia sprzedaży,
-Material Request Detail,Szczegółowy wniosek o materiał,
-Get Material Request,Uzyskaj Materiał Zamówienie,
-Material Requests,materiał Wnioski,
-Get Items For Work Order,Zdobądź przedmioty na zlecenie pracy,
-Material Request Planning,Planowanie zapotrzebowania materiałowego,
-Include Non Stock Items,Uwzględnij pozycje niepubliczne,
-Include Subcontracted Items,Uwzględnij elementy podwykonawstwa,
-Ignore Existing Projected Quantity,Ignoruj istniejącą przewidywaną ilość,
-"To know more about projected quantity, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">click here</a>.","Aby dowiedzieć się więcej o przewidywanej ilości, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">kliknij tutaj</a> .",
-Download Required Materials,Pobierz wymagane materiały,
-Get Raw Materials For Production,Zdobądź surowce do produkcji,
-Total Planned Qty,Całkowita planowana ilość,
-Total Produced Qty,Całkowita ilość wyprodukowanej,
-Material Requested,Żądany materiał,
-Production Plan Item,Przedmiot planu produkcji,
-Make Work Order for Sub Assembly Items,Wykonaj zlecenie pracy dla elementów podzespołu,
-"If enabled, system will create the work order for the exploded items against which BOM is available.","Jeśli ta opcja jest włączona, system utworzy zlecenie pracy dla rozstrzelonych elementów, dla których dostępna jest LM.",
-Planned Start Date,Planowana data rozpoczęcia,
-Quantity and Description,Ilość i opis,
-material_request_item,material_request_item,
-Product Bundle Item,Pakiet produktów Artykuł,
-Production Plan Material Request,Produkcja Plan Materiał Zapytanie,
-Production Plan Sales Order,Zamówienie sprzedaży plany produkcji,
-Sales Order Date,Data Zlecenia,
-Routing Name,Nazwa trasy,
-MFG-WO-.YYYY.-,MFG-WO-.RRRR.-,
-Item To Manufacture,Rzecz do wyprodukowania,
-Material Transferred for Manufacturing,Materiał Przeniesiony do Produkowania,
-Manufactured Qty,Ilość wyprodukowanych,
-Use Multi-Level BOM,Używaj wielopoziomowych zestawień materiałowych,
-Plan material for sub-assemblies,Materiał plan podzespołów,
-Skip Material Transfer to WIP Warehouse,Pomiń transfer materiałów do magazynu WIP,
-Check if material transfer entry is not required,"Sprawdź, czy nie ma konieczności wczytywania materiału",
-Backflush Raw Materials From Work-in-Progress Warehouse,Surowiec do płukania zwrotnego z magazynu w toku,
-Update Consumed Material Cost In Project,Zaktualizuj zużyty koszt materiałowy w projekcie,
-Warehouses,Magazyny,
-This is a location where raw materials are available.,"Jest to miejsce, w którym dostępne są surowce.",
-Work-in-Progress Warehouse,Magazyn z produkcją w toku,
-This is a location where operations are executed.,"Jest to miejsce, w którym wykonywane są operacje.",
-This is a location where final product stored.,"Jest to miejsce, w którym przechowywany jest produkt końcowy.",
-Scrap Warehouse,złom Magazyn,
-This is a location where scraped materials are stored.,"Jest to miejsce, w którym przechowywane są zeskrobane materiały.",
-Required Items,wymagane przedmioty,
-Actual Start Date,Rzeczywista data rozpoczęcia,
-Planned End Date,Planowana data zakończenia,
-Actual End Date,Rzeczywista Data Zakończenia,
-Operation Cost,Koszt operacji,
-Planned Operating Cost,Planowany koszt operacyjny,
-Actual Operating Cost,Rzeczywisty koszt operacyjny,
-Additional Operating Cost,Dodatkowy koszt operacyjny,
-Total Operating Cost,Całkowity koszt operacyjny,
-Manufacture against Material Request,Wytwarzanie przeciwko Materiały Zamówienie,
-Work Order Item,Pozycja zlecenia pracy,
-Available Qty at Source Warehouse,Dostępne ilości w magazynie źródłowym,
-Available Qty at WIP Warehouse,Dostępne ilości w magazynie WIP,
-Work Order Operation,Działanie zlecenia pracy,
-Operation Description,Opis operacji,
-Operation completed for how many finished goods?,Operacja zakończona na jak wiele wyrobów gotowych?,
-Work in Progress,Produkty w toku,
-Estimated Time and Cost,Szacowany czas i koszt,
-Planned Start Time,Planowany czas rozpoczęcia,
-Planned End Time,Planowany czas zakończenia,
-in Minutes,W ciągu kilku minut,
-Actual Time and Cost,Rzeczywisty Czas i Koszt,
-Actual Start Time,Rzeczywisty Czas Rozpoczęcia,
-Actual End Time,Rzeczywisty czas zakończenia,
-Updated via 'Time Log',"Aktualizowana przez ""Czas Zaloguj""",
-Actual Operation Time,Rzeczywisty Czas pracy,
-in Minutes\nUpdated via 'Time Log',"w minutach \n Aktualizacja poprzez ""Czas Zaloguj""",
-(Hour Rate / 60) * Actual Operation Time,(Godzina Kursy / 60) * Rzeczywista Czas pracy,
-Workstation Name,Nazwa stacji roboczej,
-Production Capacity,Moce produkcyjne,
-Operating Costs,Koszty operacyjne,
-Electricity Cost,Koszt energii elekrycznej,
-per hour,na godzinę,
-Consumable Cost,Koszt Konsumpcyjny,
-Rent Cost,Koszt Wynajmu,
-Wages,Zarobki,
-Wages per hour,Zarobki na godzinę,
-Net Hour Rate,Stawka godzinowa Netto,
-Workstation Working Hour,Godziny robocze Stacji Roboczej,
-Certification Application,Aplikacja certyfikacyjna,
-Name of Applicant,Nazwa wnioskodawcy,
-Certification Status,Status certyfikacji,
-Yet to appear,Jeszcze się pojawi,
-Certified,Atestowany,
-Not Certified,Brak certyfikatu,
-USD,USD,
-INR,INR,
-Certified Consultant,Certyfikowany konsultant,
-Name of Consultant,Imię i nazwisko konsultanta,
-Certification Validity,Ważność certyfikacji,
-Discuss ID,Omów ID,
-GitHub ID,Identyfikator GitHub,
-Non Profit Manager,Non Profit Manager,
-Chapter Head,Rozdział Głowy,
-Meetup Embed HTML,Meetup Osadź HTML,
-chapters/chapter_name\nleave blank automatically set after saving chapter.,rozdziały / chapter_name pozostaw puste puste automatycznie ustawione po zapisaniu rozdziału.,
-Chapter Members,Członkowie rozdziału,
-Members,Członkowie,
-Chapter Member,Członek rozdziału,
-Website URL,URL strony WWW,
-Leave Reason,Powód Nieobecności,
-Donor Name,Nazwa dawcy,
-Donor Type,Rodzaj dawcy,
-Withdrawn,Zamknięty w sobie,
-Grant Application Details ,Przyznaj szczegóły aplikacji,
-Grant Description,Opis dotacji,
-Requested Amount,Wnioskowana kwota,
-Has any past Grant Record,Ma jakąkolwiek przeszłość Grant Record,
-Show on Website,Pokaż na stronie internetowej,
-Assessment  Mark (Out of 10),Ocena (na 10),
-Assessment  Manager,Menedżer oceny,
-Email Notification Sent,Wysłane powiadomienie e-mail,
-NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-,
-Membership Expiry Date,Data wygaśnięcia członkostwa,
-Razorpay Details,Szczegóły Razorpay,
-Subscription ID,Identyfikator subskrypcji,
-Customer ID,Identyfikator klienta,
-Subscription Activated,Subskrypcja aktywowana,
-Subscription Start ,Rozpocznij subskrypcję,
-Subscription End,Koniec subskrypcji,
-Non Profit Member,Członek non profit,
-Membership Status,Status członkostwa,
-Member Since,Członek od,
-Payment ID,Identyfikator płatności,
-Membership Settings,Ustawienia członkostwa,
-Enable RazorPay For Memberships,Włącz RazorPay dla członkostwa,
-RazorPay Settings,Ustawienia RazorPay,
-Billing Cycle,Cykl rozliczeniowy,
-Billing Frequency,Częstotliwość rozliczeń,
-"The number of billing cycles for which the customer should be charged. For example, if a customer is buying a 1-year membership that should be billed on a monthly basis, this value should be 12.","Liczba cykli rozliczeniowych, za które klient powinien zostać obciążony. Na przykład, jeśli klient kupuje roczne członkostwo, które powinno być rozliczane co miesiąc, ta wartość powinna wynosić 12.",
-Razorpay Plan ID,Identyfikator planu Razorpay,
-Volunteer Name,Nazwisko wolontariusza,
-Volunteer Type,Typ wolontariusza,
-Availability and Skills,Dostępność i umiejętności,
-Availability,Dostępność,
-Weekends,Weekendy,
-Availability Timeslot,Dostępność Timeslot,
-Morning,Ranek,
-Afternoon,Popołudnie,
-Evening,Wieczór,
-Anytime,W każdej chwili,
-Volunteer Skills,Umiejętności ochotnicze,
-Volunteer Skill,Wolontariat,
-Homepage,Strona główna,
-Hero Section Based On,Sekcja bohatera na podstawie,
-Homepage Section,Sekcja strony głównej,
-Hero Section,Sekcja bohatera,
-Tag Line,Slogan reklamowy,
-Company Tagline for website homepage,Slogan reklamowy firmy na głównej stronie,
-Company Description for website homepage,Opis firmy na stronie głównej,
-Homepage Slideshow,Pokaz slajdów na stronie głównej,
-"URL for ""All Products""",URL do wszystkich produktów,
-Products to be shown on website homepage,Produkty przeznaczone do pokazania na głównej stronie,
-Homepage Featured Product,Ciekawa Strona produktu,
-route,trasa,
-Section Based On,Sekcja na podstawie,
-Section Cards,Karty sekcji,
-Number of Columns,Liczba kolumn,
-Number of columns for this section. 3 cards will be shown per row if you select 3 columns.,"Liczba kolumn dla tej sekcji. 3 wiersze zostaną wyświetlone w wierszu, jeśli wybierzesz 3 kolumny.",
-Section HTML,Sekcja HTML,
-Use this field to render any custom HTML in the section.,To pole służy do renderowania dowolnego niestandardowego kodu HTML w sekcji.,
-Section Order,Kolejność sekcji,
-"Order in which sections should appear. 0 is first, 1 is second and so on.","Kolejność, w której sekcje powinny się pojawić. 0 jest pierwsze, 1 jest drugie i tak dalej.",
-Homepage Section Card,Strona główna Karta sekcji,
-Subtitle,Podtytuł,
-Products Settings,produkty Ustawienia,
-Home Page is Products,Strona internetowa firmy jest produktem,
-"If checked, the Home page will be the default Item Group for the website","Jeśli zaznaczone, strona główna będzie Grupa domyślna pozycja na stronie",
-Show Availability Status,Pokaż status dostępności,
-Product Page,Strona produktu,
-Products per Page,Produkty na stronę,
-Enable Field Filters,Włącz filtry pola,
-Item Fields,Pola przedmiotów,
-Enable Attribute Filters,Włącz filtry atrybutów,
-Attributes,Atrybuty,
-Hide Variants,Ukryj warianty,
-Website Attribute,Atrybut strony,
-Attribute,Atrybut,
-Website Filter Field,Pole filtru witryny,
-Activity Cost,Aktywny Koszt,
-Billing Rate,Kursy rozliczeniowe,
-Costing Rate,Wskaźnik zestawienia kosztów,
-title,tytuł,
-Projects User,Użytkownik projektu,
-Default Costing Rate,Domyślnie Costing Cena,
-Default Billing Rate,Domyślnie Cena płatności,
-Dependent Task,Zadanie zależne,
-Project Type,Typ projektu,
-% Complete Method,Kompletna Metoda%,
-Task Completion,zadanie Zakończenie,
-Task Progress,Postęp wykonywania zadania,
-% Completed,% ukończone,
-From Template,Z szablonu,
-Project will be accessible on the website to these users,Projekt będzie dostępny na stronie internetowej dla tych użytkowników,
-Copied From,Skopiowano z,
-Start and End Dates,Daty rozpoczęcia i zakończenia,
-Actual Time (in Hours),Rzeczywisty czas (w godzinach),
-Costing and Billing,Kalkulacja kosztów i fakturowanie,
-Total Costing Amount (via Timesheets),Łączna kwota kosztów (za pośrednictwem kart pracy),
-Total Expense Claim (via Expense Claims),Łączny koszt roszczenie (przez zwrot kosztów),
-Total Purchase Cost (via Purchase Invoice),Całkowity koszt zakupu (faktura zakupu za pośrednictwem),
-Total Sales Amount (via Sales Order),Całkowita kwota sprzedaży (poprzez zamówienie sprzedaży),
-Total Billable Amount (via Timesheets),Całkowita kwota do naliczenia (za pośrednictwem kart pracy),
-Total Billed Amount (via Sales Invoices),Całkowita kwota faktury (za pośrednictwem faktur sprzedaży),
-Total Consumed Material Cost  (via Stock Entry),Całkowity koszt materiałów konsumpcyjnych (poprzez wprowadzenie do magazynu),
-Gross Margin,Marża brutto,
-Gross Margin %,Marża brutto %,
-Monitor Progress,Monitorowanie postępu,
-Collect Progress,Zbierz postęp,
-Frequency To Collect Progress,Częstotliwość zbierania postępów,
-Twice Daily,Dwa razy dziennie,
-First Email,Pierwszy e-mail,
-Second Email,Drugi e-mail,
-Time to send,Czas wysłać,
-Day to Send,Dzień na wysłanie,
-Message will be sent to the users to get their status on the Project,Wiadomość zostanie wysłana do użytkowników w celu uzyskania ich statusu w Projekcie,
-Projects Manager,Kierownik Projektów,
-Project Template,Szablon projektu,
-Project Template Task,Zadanie szablonu projektu,
-Begin On (Days),Rozpocznij od (dni),
-Duration (Days),Czas trwania (dni),
-Project Update,Aktualizacja projektu,
-Project User,Użytkownik projektu,
-View attachments,Wyświetl załączniki,
-Projects Settings,Ustawienia projektów,
-Ignore Workstation Time Overlap,Zignoruj nakładanie się czasu w stacji roboczej,
-Ignore User Time Overlap,Zignoruj nakładanie się czasu użytkownika,
-Ignore Employee Time Overlap,Zignoruj nakładanie się czasu pracownika,
-Weight,Waga,
-Parent Task,Zadanie rodzica,
-Timeline,Oś czasu,
-Expected Time (in hours),Oczekiwany czas (w godzinach),
-% Progress,% Postęp,
-Is Milestone,Jest Milestone,
-Task Description,Opis zadania,
-Dependencies,Zależności,
-Dependent Tasks,Zadania zależne,
-Depends on Tasks,Zależy Zadania,
-Actual Start Date (via Time Sheet),Faktyczna data rozpoczęcia (przez czas arkuszu),
-Actual Time (in hours),Rzeczywisty czas (w godzinach),
-Actual End Date (via Time Sheet),Faktyczna data zakończenia (przez czas arkuszu),
-Total Costing Amount (via Time Sheet),Całkowita kwota Costing (przez czas arkuszu),
-Total Expense Claim (via Expense Claim),Razem zwrot kosztów (przez zwrot kosztów),
-Total Billing Amount (via Time Sheet),Całkowita kwota płatności (poprzez Czas Sheet),
-Review Date,Data Przeglądu,
-Closing Date,Data zamknięcia,
-Task Depends On,Zadanie zależne od,
-Task Type,Typ zadania,
-TS-.YYYY.-,TS-.YYYY.-,
-Employee Detail,Szczegóły urzędnik,
-Billing Details,Szczegóły płatności,
-Total Billable Hours,Całkowita liczba godzin rozliczanych,
-Total Billed Hours,Wszystkich Zafakturowane Godziny,
-Total Costing Amount,Łączna kwota Costing,
-Total Billable Amount,Całkowita kwota podlegająca rozliczeniom,
-Total Billed Amount,Kwota całkowita Zapowiadane,
-% Amount Billed,% wartości rozliczonej,
-Hrs,godziny,
-Costing Amount,Kwota zestawienia kosztów,
-Corrective/Preventive,Korygujące / zapobiegawcze,
-Corrective,Poprawczy,
-Preventive,Zapobiegawczy,
-Resolution,Rozstrzygnięcie,
-Resolutions,Postanowienia,
-Quality Action Resolution,Rezolucja dotycząca jakości działania,
-Quality Feedback Parameter,Parametr sprzężenia zwrotnego jakości,
-Quality Feedback Template Parameter,Parametr szablonu opinii o jakości,
-Quality Goal,Cel jakości,
-Monitoring Frequency,Monitorowanie częstotliwości,
-Weekday,Dzień powszedni,
-Objectives,Cele,
-Quality Goal Objective,Cel celu jakości,
-Objective,Cel,
-Agenda,Program,
-Minutes,Minuty,
-Quality Meeting Agenda,Agenda spotkania jakości,
-Quality Meeting Minutes,Protokół spotkania jakości,
-Minute,Minuta,
-Parent Procedure,Procedura rodzicielska,
-Processes,Procesy,
-Quality Procedure Process,Proces procedury jakości,
-Process Description,Opis procesu,
-Link existing Quality Procedure.,Połącz istniejącą procedurę jakości.,
-Additional Information,Dodatkowe informacje,
-Quality Review Objective,Cel przeglądu jakości,
-DATEV Settings,Ustawienia DATEV,
-Regional,Regionalny,
-Consultant ID,ID konsultanta,
-GST HSN Code,Kod GST HSN,
-HSN Code,Kod HSN,
-GST Settings,Ustawienia GST,
-GST Summary,Podsumowanie GST,
-GSTIN Email Sent On,Wysłano pocztę GSTIN,
-GST Accounts,Konta GST,
-B2C Limit,Limit B2C,
-Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Ustaw wartość faktury dla B2C. B2CL i B2CS obliczane na podstawie tej wartości faktury.,
-GSTR 3B Report,Raport GSTR 3B,
-January,styczeń,
-February,luty,
-March,Marsz,
-April,kwiecień,
-May,Maj,
-June,czerwiec,
-July,lipiec,
-August,sierpień,
-September,wrzesień,
-October,październik,
-November,listopad,
-December,grudzień,
-JSON Output,Wyjście JSON,
-Invoices with no Place Of Supply,Faktury bez miejsca dostawy,
-Import Supplier Invoice,Importuj fakturę od dostawcy,
-Invoice Series,Seria faktur,
-Upload XML Invoices,Prześlij faktury XML,
-Zip File,Plik zip,
-Import Invoices,Importuj faktury,
-Click on Import Invoices button once the zip file has been attached to the document. Any errors related to processing will be shown in the Error Log.,Kliknij przycisk Importuj faktury po dołączeniu pliku zip do dokumentu. Wszelkie błędy związane z przetwarzaniem zostaną wyświetlone w dzienniku błędów.,
-Lower Deduction Certificate,Certyfikat niższego potrącenia,
-Certificate Details,Szczegóły certyfikatu,
-194A,194A,
-194C,194C,
-194D,194D,
-194H,194H,
-194I,194I,
-194J,194J,
-194LA,194LA,
-194LBB,194LBB,
-194LBC,194LBC,
-Certificate No,Certyfikat nr,
-Deductee Details,Szczegóły dotyczące odliczonego,
-PAN No,Nr PAN,
-Validity Details,Szczegóły dotyczące ważności,
-Rate Of TDS As Per Certificate,Stawka TDS zgodnie z certyfikatem,
-Certificate Limit,Limit certyfikatu,
-Invoice Series Prefix,Prefiks serii faktur,
-Active Menu,Aktywne menu,
-Restaurant Menu,Menu restauracji,
-Price List (Auto created),Cennik (utworzony automatycznie),
-Restaurant Manager,Menadżer restauracji,
-Restaurant Menu Item,Menu restauracji,
-Restaurant Order Entry,Wprowadzanie do restauracji,
-Restaurant Table,Stolik Restauracyjny,
-Click Enter To Add,Kliknij Enter To Add,
-Last Sales Invoice,Ostatnia sprzedaż faktury,
-Current Order,Aktualne zamówienie,
-Restaurant Order Entry Item,Restauracja Order Entry Pozycja,
-Served,Serwowane,
-Restaurant Reservation,Rezerwacja restauracji,
-Waitlisted,Na liście Oczekujących,
-No Show,Brak pokazu,
-No of People,Liczba osób,
-Reservation Time,Czas rezerwacji,
-Reservation End Time,Rezerwacja Koniec czasu,
-No of Seats,Liczba miejsc,
-Minimum Seating,Minimalne miejsce siedzące,
-"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment. ","Śledź kampanię sprzedażową. Śledź Tropy, Wyceny, Zamówienia Sprzedaży etc. z kampanii by zmierzyć zwrot z inwestycji.",
-SAL-CAM-.YYYY.-,SAL-CAM-.YYYY.-,
-Campaign Schedules,Harmonogramy kampanii,
-Buyer of Goods and Services.,Nabywca Towarów i Usług.,
-CUST-.YYYY.-,CUST-.YYYY.-.-,
-Default Company Bank Account,Domyślne firmowe konto bankowe,
-From Lead,Od śladu,
-Account Manager,Menadżer konta,
-Allow Sales Invoice Creation Without Sales Order,Zezwalaj na tworzenie faktur sprzedaży bez zamówienia sprzedaży,
-Allow Sales Invoice Creation Without Delivery Note,Zezwalaj na tworzenie faktur sprzedaży bez potwierdzenia dostawy,
-Default Price List,Domyślny cennik,
-Primary Address and Contact Detail,Główny adres i dane kontaktowe,
-"Select, to make the customer searchable with these fields","Wybierz, aby klient mógł wyszukać za pomocą tych pól",
-Customer Primary Contact,Kontakt główny klienta,
-"Reselect, if the chosen contact is edited after save","Ponownie wybierz, jeśli wybrany kontakt jest edytowany po zapisaniu",
-Customer Primary Address,Główny adres klienta,
-"Reselect, if the chosen address is edited after save","Ponownie wybierz, jeśli wybrany adres jest edytowany po zapisaniu",
-Primary Address,adres główny,
-Mention if non-standard receivable account,"Wskazać, jeśli niestandardowe konto należności",
-Credit Limit and Payment Terms,Limit kredytowy i warunki płatności,
-Additional information regarding the customer.,Dodatkowe informacje na temat klienta.,
-Sales Partner and Commission,Partner sprzedaży i Prowizja,
-Commission Rate,Wartość prowizji,
-Sales Team Details,Szczegóły dotyczące Teamu Sprzedażowego,
-Customer POS id,Identyfikator punktu sprzedaży klienta,
-Customer Credit Limit,Limit kredytu klienta,
-Bypass Credit Limit Check at Sales Order,Pomiń limit kredytowy w zleceniu klienta,
-Industry Type,Typ Przedsiębiorstwa,
-MAT-INS-.YYYY.-,MAT-INS-.YYYY.-,
-Installation Date,Data instalacji,
-Installation Time,Czas instalacji,
-Installation Note Item,,
-Installed Qty,Liczba instalacji,
-Lead Source,,
-Period Start Date,Data rozpoczęcia okresu,
-Period End Date,Data zakończenia okresu,
-Cashier,Kasjer,
-Difference,Różnica,
-Modes of Payment,Tryby płatności,
-Linked Invoices,Powiązane faktury,
-POS Closing Voucher Details,Szczegóły kuponu zamykającego POS,
-Collected Amount,Zebrana kwota,
-Expected Amount,Oczekiwana kwota,
-POS Closing Voucher Invoices,Faktury z zamknięciem kuponu,
-Quantity of Items,Ilość przedmiotów,
-"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. \n\nThe package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".\n\nFor Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.\n\nNote: BOM = Bill of Materials","Łączna grupa przedmioty ** ** ** Przedmiot do innego **. Jest to przydatne, jeśli łączenie pewnej ** przedmioty ** w pakiet i utrzymania zapasów pakowanych ** rzeczy ** a nie sumę ** rzecz **. Pakiet ** Pozycja ** będzie miał ""Czy Pozycja Zdjęcie"", jak ""Nie"" i ""Czy Sales Item"", jak ""Tak"". Dla przykładu: Jeśli sprzedajesz Laptopy i plecaki oddzielnie i mają specjalną cenę, jeśli klient kupuje oba, a następnie Laptop + Plecak będzie nowy Bundle wyrobów poz. Uwaga: ZM = Zestawienie Materiałów",
-Parent Item,Element nadrzędny,
-List items that form the package.,Lista elementów w pakiecie,
-SAL-QTN-.YYYY.-,SAL-QTN-.RRRR.-,
-Quotation To,Wycena dla,
-Rate at which customer's currency is converted to company's base currency,Stawka przy użyciu której Waluta Klienta jest konwertowana do podstawowej waluty firmy,
-Rate at which Price list currency is converted to company's base currency,Stawka przy użyciu której waluta Listy Cen jest konwertowana do podstawowej waluty firmy,
-Additional Discount and Coupon Code,Dodatkowy kod rabatowy i kuponowy,
-Referral Sales Partner,Polecony partner handlowy,
-In Words will be visible once you save the Quotation.,,
-Term Details,Szczegóły warunków,
-Quotation Item,Przedmiot oferty,
-Against Doctype,,
-Against Docname,,
-Additional Notes,Dodatkowe uwagi,
-SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-,
-Skip Delivery Note,Pomiń dowód dostawy,
-In Words will be visible once you save the Sales Order.,"Słownie, będzie widoczne w Zamówieniu Sprzedaży, po zapisaniu",
-Track this Sales Order against any Project,Śledź zamówienie sprzedaży w każdym projekcie,
-Billing and Delivery Status,Fakturowanie i status dostawy,
-Not Delivered,Nie dostarczony,
-Fully Delivered,Całkowicie dostarczono,
-Partly Delivered,Częściowo Dostarczono,
-Not Applicable,Nie dotyczy,
-%  Delivered,% dostarczono,
-% of materials delivered against this Sales Order,% materiałów dostarczonych w ramach zlecenia sprzedaży,
-% of materials billed against this Sales Order,% materiałów rozliczonych w ramach tego zlecenia sprzedaży,
-Not Billed,Nie zaksięgowany,
-Fully Billed,Całkowicie Rozliczone,
-Partly Billed,Częściowo Zapłacono,
-Ensure Delivery Based on Produced Serial No,Zapewnij dostawę na podstawie wyprodukowanego numeru seryjnego,
-Supplier delivers to Customer,Dostawca dostarcza Klientowi,
-Delivery Warehouse,Magazyn Dostawa,
-Planned Quantity,Planowana ilość,
-For Production,Dla Produkcji,
-Work Order Qty,Ilość zlecenia pracy,
-Produced Quantity,Wyprodukowana ilość,
-Used for Production Plan,Używane do Planu Produkcji,
-Sales Partner Type,Typ partnera handlowego,
-Contact No.,Numer Kontaktu,
-Contribution (%),Udział (%),
-Contribution to Net Total,,
-Selling Settings,Ustawienia sprzedaży,
-Settings for Selling Module,Ustawienia modułu sprzedaży,
-Customer Naming By,,
-Campaign Naming By,Konwencja nazewnictwa Kampanii przez,
-Default Customer Group,Domyślna grupa klientów,
-Default Territory,Domyślne terytorium,
-Close Opportunity After Days,Po blisko Szansa Dni,
-Default Quotation Validity Days,Domyślna ważność oferty,
-Sales Update Frequency,Częstotliwość aktualizacji sprzedaży,
-Each Transaction,Każda transakcja,
-SMS Center,Centrum SMS,
-Send To,Wyślij do,
-All Contact,Wszystkie dane Kontaktu,
-All Customer Contact,Wszystkie dane kontaktowe klienta,
-All Supplier Contact,Dane wszystkich dostawców,
-All Sales Partner Contact,Wszystkie dane kontaktowe Partnera Sprzedaży,
-All Lead (Open),Wszystkie Leady (Otwarte),
-All Employee (Active),Wszyscy pracownicy (aktywni),
-All Sales Person,Wszyscy Sprzedawcy,
-Create Receiver List,Stwórz listę odbiorców,
-Receiver List,Lista odbiorców,
-Messages greater than 160 characters will be split into multiple messages,Wiadomości dłuższe niż 160 znaków zostaną podzielone na kilka wiadomości,
-Total Characters,Wszystkich Postacie,
-Total Message(s),Razem ilość wiadomości,
-Authorization Control,Kontrola Autoryzacji,
-Authorization Rule,Reguła autoryzacji,
-Average Discount,Średni Rabat,
-Customerwise Discount,Zniżka dla klienta,
-Itemwise Discount,Pozycja Rabat automatyczny,
-Customer or Item,Klient lub przedmiotu,
-Customer / Item Name,Klient / Nazwa Przedmiotu,
-Authorized Value,Autoryzowany Wartość,
-Applicable To (Role),Stosowne dla (Rola),
-Applicable To (Employee),Stosowne dla (Pracownik),
-Applicable To (User),Stosowne dla (Użytkownik),
-Applicable To (Designation),Stosowne dla (Nominacja),
-Approving Role (above authorized value),Zatwierdzanie rolę (powyżej dopuszczonego wartości),
-Approving User  (above authorized value),Zatwierdzanie autoryzowanego użytkownika (powyżej wartości),
-Brand Defaults,Domyślne marki,
-Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Osobowość prawna / Filia w oddzielny planu kont należących do Organizacji.,
-Change Abbreviation,Zmień Skrót,
-Parent Company,Przedsiębiorstwo macierzyste,
-Default Values,Domyślne wartości,
-Default Holiday List,Domyślna lista urlopowa,
-Default Selling Terms,Domyślne warunki sprzedaży,
-Default Buying Terms,Domyślne warunki zakupu,
-Create Chart Of Accounts Based On,Tworzenie planu kont w oparciu o,
-Standard Template,Szablon Standardowy,
-Existing Company,Istniejąca firma,
-Chart Of Accounts Template,Szablon planu kont,
-Existing Company ,istniejące firmy,
-Date of Establishment,Data założenia,
-Sales Settings,Ustawienia sprzedaży,
-Monthly Sales Target,Miesięczny cel sprzedaży,
-Sales Monthly History,Historia miesięczna sprzedaży,
-Transactions Annual History,Historia transakcji,
-Total Monthly Sales,Łączna miesięczna sprzedaż,
-Default Cash Account,Domyślne Konto Gotówkowe,
-Default Receivable Account,Domyślnie konto Rozrachunki z odbiorcami,
-Round Off Cost Center,Zaokrąglenia - Centrum Kosztów,
-Discount Allowed Account,Konto Dozwolone,
-Discount Received Account,Konto otrzymane z rabatem,
-Exchange Gain / Loss Account,Wymiana Zysk / strat,
-Unrealized Exchange Gain/Loss Account,Niezrealizowane konto zysku / straty z wymiany,
-Allow Account Creation Against Child Company,Zezwól na tworzenie konta przeciwko firmie podrzędnej,
-Default Payable Account,Domyślne konto Rozrachunki z dostawcami,
-Default Employee Advance Account,Domyślne konto Advance pracownika,
-Default Cost of Goods Sold Account,Domyślne Konto Wartości Dóbr Sprzedanych,
-Default Income Account,Domyślne konto przychodów,
-Default Deferred Revenue Account,Domyślne konto odroczonego przychodu,
-Default Deferred Expense Account,Domyślne konto odroczonego kosztu,
-Default Payroll Payable Account,Domyślny Płace Płatne konta,
-Default Expense Claim Payable Account,Rachunek wymagalny zapłaty domyślnego kosztu,
-Stock Settings,Ustawienia magazynu,
-Enable Perpetual Inventory,Włącz wieczne zapasy,
-Default Inventory Account,Domyślne konto zasobów reklamowych,
-Stock Adjustment Account,Konto korekty,
-Fixed Asset Depreciation Settings,Ustawienia Amortyzacja środka trwałego,
-Series for Asset Depreciation Entry (Journal Entry),Seria dla pozycji amortyzacji aktywów (wpis w czasopiśmie),
-Gain/Loss Account on Asset Disposal,Konto Zysk / Strata na Aktywów pozbywaniu,
-Asset Depreciation Cost Center,Zaleta Centrum Amortyzacja kosztów,
-Budget Detail,Szczegóły Budżetu,
-Exception Budget Approver Role,Rola zatwierdzającego wyjątku dla budżetu,
-Company Info,Informacje o firmie,
-For reference only.,Wyłącznie w celach informacyjnych.,
-Company Logo,Logo firmy,
-Date of Incorporation,Data przyłączenia,
-Date of Commencement,Data rozpoczęcia,
-Phone No,Nr telefonu,
-Company Description,Opis Firmy,
-Registration Details,Szczegóły Rejestracji,
-Company registration numbers for your reference. Tax numbers etc.,,
-Delete Company Transactions,Usuń Transakcje Spółki,
-Currency Exchange,Wymiana Walut,
-Specify Exchange Rate to convert one currency into another,Określ Kursy walut konwersji jednej waluty w drugą,
-From Currency,Od Waluty,
-To Currency,Do przewalutowania,
-For Buying,Do kupienia,
-For Selling,Do sprzedania,
-Customer Group Name,Nazwa Grupy Klientów,
-Parent Customer Group,Nadrzędna Grupa Klientów,
-Only leaf nodes are allowed in transaction,,
-Mention if non-standard receivable account applicable,"Wspomnieć, jeśli nie standardowe konto należności dotyczy",
-Credit Limits,Limity kredytowe,
-Email Digest,przetwarzanie emaila,
-Send regular summary reports via Email.,Wyślij regularne raporty podsumowujące poprzez e-mail.,
-Email Digest Settings,ustawienia przetwarzania maila,
-How frequently?,Jak często?,
-Next email will be sent on:,Kolejny e-mali zostanie wysłany w dniu:,
-Note: Email will not be sent to disabled users,Uwaga: E-mail nie zostanie wysłany do nieaktywnych użytkowników,
-Profit & Loss,Rachunek zysków i strat,
-New Income,Nowy dochodowy,
-New Expenses,Nowe wydatki,
-Annual Income,Roczny dochód,
-Annual Expenses,roczne koszty,
-Bank Balance,Saldo bankowe,
-Bank Credit Balance,Saldo kredytu bankowego,
-Receivables,Należności,
-Payables,Zobowiązania,
-Sales Orders to Bill,Zlecenia sprzedaży do rachunku,
-Purchase Orders to Bill,Zamówienia zakupu do rachunku,
-New Sales Orders,,
-New Purchase Orders,,
-Sales Orders to Deliver,Zlecenia sprzedaży do realizacji,
-Purchase Orders to Receive,Zamówienia zakupu do odbioru,
-New Purchase Invoice,Nowa faktura zakupu,
-New Quotations,Nowa oferta,
-Open Quotations,Otwarte oferty,
-Open Issues,Otwarte kwestie,
-Open Projects,Otwarte projekty,
-Purchase Orders Items Overdue,Przedmioty zamówienia przeterminowane,
-Upcoming Calendar Events,Nadchodzące wydarzenia w kalendarzu,
-Open To Do,Otwórz do zrobienia,
-Add Quote,Dodaj Cytat,
-Global Defaults,Globalne wartości domyślne,
-Default Company,Domyślna Firma,
-Current Fiscal Year,Obecny rok fiskalny,
-Default Distance Unit,Domyślna jednostka odległości,
-Hide Currency Symbol,Ukryj symbol walutowy,
-Do not show any symbol like $ etc next to currencies.,"Nie pokazuj żadnych symboli przy walutach, takich jak $",
-"If disable, 'Rounded Total' field will not be visible in any transaction","Jeśli wyłączone, pozycja 'Końcowa zaokrąglona suma' nie będzie widoczna w żadnej transakcji",
-Disable In Words,Wyłącz w słowach,
-"If disable, 'In Words' field will not be visible in any transaction",Jeśli wyłączyć &quot;w słowach&quot; pole nie będzie widoczne w każdej transakcji,
-Item Classification,Pozycja Klasyfikacja,
-General Settings,Ustawienia ogólne,
-Item Group Name,Element Nazwa grupy,
-Parent Item Group,Grupa Elementu nadrzędnego,
-Item Group Defaults,Domyślne grupy artykułów,
-Item Tax,Podatek dla tej pozycji,
-Check this if you want to show in website,Zaznacz czy chcesz uwidocznić to na stronie WWW,
-Show this slideshow at the top of the page,Pokaż slideshow na górze strony,
-HTML / Banner that will show on the top of product list.,"HTML / Banner, który pokaże się na górze listy produktów.",
-Set prefix for numbering series on your transactions,Ustaw prefiks dla numeracji serii na swoich transakcji,
-Setup Series,Konfigurowanie serii,
-Select Transaction,Wybierz Transakcję,
-Help HTML,Pomoc HTML,
-Series List for this Transaction,Lista serii dla tej transakcji,
-User must always select,Użytkownik musi zawsze zaznaczyć,
-Check this if you want to force the user to select a series before saving. There will be no default if you check this.,,
-Update Series,Zaktualizuj Serię,
-Change the starting / current sequence number of an existing series.,Zmień początkowy / obecny numer seryjny istniejącej serii.,
-Prefix,Prefiks,
-Current Value,Bieżąca Wartość,
-This is the number of the last created transaction with this prefix,Jest to numer ostatniej transakcji utworzonego z tym prefiksem,
-Update Series Number,Zaktualizuj Numer Serii,
-Quotation Lost Reason,Utracony Powód Wyceny,
-A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,"Dystrybutor strona trzecia / handlowiec / prowizji agenta / partner / sprzedawcę, który sprzedaje produkty firm z tytułu prowizji.",
-Sales Partner Name,Imię Partnera Sprzedaży,
-Partner Type,Typ Partnera,
-Address & Contacts,Adresy i kontakty,
-Address Desc,Opis adresu,
-Contact Desc,Opis kontaktu,
-Sales Partner Target,Cel Partnera Sprzedaży,
-Targets,Cele,
-Show In Website,Pokaż na stronie internetowej,
-Referral Code,kod polecającego,
-To Track inbound purchase,Aby śledzić zakupy przychodzące,
-Logo,Logo,
-Partner website,Strona partnera,
-All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Wszystkie transakcje sprzedaży mogą być oznaczone przed wieloma ** Osoby sprzedaży **, dzięki czemu można ustawić i monitorować cele.",
-Name and Employee ID,Imię i Identyfikator Pracownika,
-Sales Person Name,Imię Sprzedawcy,
-Parent Sales Person,Nadrzędny Przedstawiciel Handlowy,
-Select company name first.,Wybierz najpierw nazwę firmy,
-Sales Person Targets,Cele Sprzedawcy,
-Set targets Item Group-wise for this Sales Person.,,
-Supplier Group Name,Nazwa grupy dostawcy,
-Parent Supplier Group,Rodzicielska grupa dostawców,
-Target Detail,Szczegóły celu,
-Target Qty,Ilość docelowa,
-Target  Amount,Kwota docelowa,
-Target Distribution,Dystrybucja docelowa,
-"Standard Terms and Conditions that can be added to Sales and Purchases.\n\nExamples:\n\n1. Validity of the offer.\n1. Payment Terms (In Advance, On Credit, part advance etc).\n1. What is extra (or payable by the Customer).\n1. Safety / usage warning.\n1. Warranty if any.\n1. Returns Policy.\n1. Terms of shipping, if applicable.\n1. Ways of addressing disputes, indemnity, liability, etc.\n1. Address and Contact of your Company.","Standardowe Zasady i warunki, które mogą być dodawane do sprzedaży i zakupów.\n\n Przykłady: \n\n 1. Ważność oferty.\n 1. Warunki płatności (z góry, na kredyt, część zaliczki itp).\n 1. Co to jest ekstra (lub płatne przez Klienta).\n 1. Bezpieczeństwo / ostrzeżenie wykorzystanie.\n 1. Gwarancja jeśli w ogóle.\n 1. Zwraca Polityka.\n 1. Warunki wysyłki, jeśli dotyczy.\n 1. Sposobów rozwiązywania sporów, odszkodowania, odpowiedzialność itp \n 1. Adres i kontakt z Twojej firmy.",
-Applicable Modules,Odpowiednie moduły,
-Terms and Conditions Help,Warunki Pomoc,
-Classification of Customers by region,Klasyfikacja Klientów od regionu,
-Territory Name,Nazwa Regionu,
-Parent Territory,Nadrzędne terytorium,
-Territory Manager,Kierownik Regionalny,
-For reference,Dla referencji,
-Territory Targets,Cele Regionalne,
-Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,,
-UOM Name,Nazwa Jednostki Miary,
-Check this to disallow fractions. (for Nos),Zaznacz to by zakazać ułamków (dla liczby jednostek),
-Website Item Group,Grupa przedmiotów strony WWW,
-Cross Listing of Item in multiple groups,Krzyż Notowania pozycji w wielu grupach,
-Default settings for Shopping Cart,Domyślne ustawienia koszyku,
-Enable Shopping Cart,Włącz Koszyk,
-Display Settings,,
-Show Public Attachments,Pokaż załączniki publiczne,
-Show Price,Pokaż cenę,
-Show Stock Availability,Pokaż dostępność zapasów,
-Show Contact Us Button,Pokaż przycisk Skontaktuj się z nami,
-Show Stock Quantity,Pokaż ilość zapasów,
-Show Apply Coupon Code,Pokaż zastosuj kod kuponu,
-Allow items not in stock to be added to cart,Zezwól na dodanie produktów niedostępnych w magazynie do koszyka,
-Prices will not be shown if Price List is not set,"Ceny nie będą wyświetlane, jeśli Cennik nie jest ustawiony",
-Quotation Series,Serie Wyeceny,
-Checkout Settings,Zamówienie Ustawienia,
-Enable Checkout,Włącz kasę,
-Payment Success Url,Płatność Sukces URL,
-After payment completion redirect user to selected page.,Po dokonaniu płatności przekierować użytkownika do wybranej strony.,
-Batch Details,Szczegóły partii,
-Batch ID,Identyfikator Partii,
-image,wizerunek,
-Parent Batch,Nadrzędna partia,
-Manufacturing Date,Data produkcji,
-Batch Quantity,Ilość partii,
-Batch UOM,UOM partii,
-Source Document Type,Typ dokumentu źródłowego,
-Source Document Name,Nazwa dokumentu źródłowego,
-Batch Description,Opis partii,
-Bin,Kosz,
-Reserved Quantity,Zarezerwowana ilość,
-Actual Quantity,Rzeczywista Ilość,
-Requested Quantity,Oczekiwana ilość,
-Reserved Qty for sub contract,Zarezerwowana ilość na podwykonawstwo,
-Moving Average Rate,Cena Średnia Ruchoma,
-FCFS Rate,Pierwsza rata,
-Customs Tariff Number,Numer taryfy celnej,
-Tariff Number,Numer taryfy,
-Delivery To,Dostawa do,
-MAT-DN-.YYYY.-,MAT-DN-.YYYY.-,
-Is Return,Czy Wróć,
-Issue Credit Note,Problem Uwaga kredytowa,
-Return Against Delivery Note,Powrót Przeciwko dostawy nocie,
-Customer's Purchase Order No,Numer Zamówienia Zakupu Klienta,
-Billing Address Name,Nazwa Adresu do Faktury,
-Required only for sample item.,,
-"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Jeśli utworzono standardowy szablon w podatku od sprzedaży i Prowizji szablonu, wybierz jedną i kliknij na przycisk poniżej.",
-In Words will be visible once you save the Delivery Note.,,
-In Words (Export) will be visible once you save the Delivery Note.,,
-Transporter Info,Informacje dotyczące przewoźnika,
-Driver Name,Imię kierowcy,
-Track this Delivery Note against any Project,Śledź potwierdzenie dostawy w każdym projekcie,
-Inter Company Reference,Referencje między firmami,
-Print Without Amount,Drukuj bez wartości,
-% Installed,% Zainstalowanych,
-% of materials delivered against this Delivery Note,% materiałów dostarczonych w stosunku do dowodu dostawy,
-Installation Status,Status instalacji,
-Excise Page Number,Akcyza numeru strony,
-Instructions,Instrukcje,
-From Warehouse,Z magazynu,
-Against Sales Order,Na podstawie zamówienia sprzedaży,
-Against Sales Order Item,Na podstawie pozycji zamówienia sprzedaży,
-Against Sales Invoice,Na podstawie faktury sprzedaży,
-Against Sales Invoice Item,Na podstawie pozycji faktury sprzedaży,
-Available Batch Qty at From Warehouse,Ilosc w serii dostępne z magazynu,
-Available Qty at From Warehouse,Dostępne szt co z magazynu,
-Delivery Settings,Ustawienia dostawy,
-Dispatch Settings,Ustawienia wysyłki,
-Dispatch Notification Template,Szablon powiadomienia o wysyłce,
-Dispatch Notification Attachment,Powiadomienie o wysyłce,
-Leave blank to use the standard Delivery Note format,"Pozostaw puste, aby używać standardowego formatu dokumentu dostawy",
-Send with Attachment,Wyślij z załącznikiem,
-Delay between Delivery Stops,Opóźnienie między przerwami w dostawie,
-Delivery Stop,Przystanek dostawy,
-Lock,Zamek,
-Visited,Odwiedzony,
-Order Information,Szczegóły zamówienia,
-Contact Information,Informacje kontaktowe,
-Email sent to,Email wysłany do,
-Dispatch Information,Informacje o wysyłce,
-Estimated Arrival,Szacowany przyjazd,
-MAT-DT-.YYYY.-,MAT-DT-.RRRR.-,
-Initial Email Notification Sent,Wstępne powiadomienie e-mail wysłane,
-Delivery Details,Szczegóły dostawy,
-Driver Email,Adres e-mail kierowcy,
-Driver Address,Adres kierowcy,
-Total Estimated Distance,Łączna przewidywana odległość,
-Distance UOM,Odległość UOM,
-Departure Time,Godzina odjazdu,
-Delivery Stops,Przerwy w dostawie,
-Calculate Estimated Arrival Times,Oblicz szacowany czas przyjazdu,
-Use Google Maps Direction API to calculate estimated arrival times,"Użyj interfejsu API Google Maps Direction, aby obliczyć szacowany czas przybycia",
-Optimize Route,Zoptymalizuj trasę,
-Use Google Maps Direction API to optimize route,"Użyj Google Maps Direction API, aby zoptymalizować trasę",
-In Transit,W tranzycie,
-Fulfillment User,Użytkownik spełniający wymagania,
-"A Product or a Service that is bought, sold or kept in stock.","Produkt lub usługa, która jest kupiona, sprzedana lub przechowywana w magazynie.",
-STO-ITEM-.YYYY.-,STO-ITEM-.RRRR.-,
-Variant Of,Wariant,
-"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Jeśli pozycja jest wariant innego elementu, a następnie opis, zdjęcia, ceny, podatki itp zostanie ustalony z szablonu, o ile nie określono wyraźnie",
-Is Item from Hub,Jest Przedmiot z Hubu,
-Default Unit of Measure,Domyślna jednostka miary,
-Maintain Stock,Utrzymanie Zapasów,
-Standard Selling Rate,Standardowy kurs sprzedaży,
-Auto Create Assets on Purchase,Automatycznie twórz zasoby przy zakupie,
-Asset Naming Series,Asset Naming Series,
-Over Delivery/Receipt Allowance (%),Over Delivery / Receipt Allowance (%),
-Barcodes,Kody kreskowe,
-Shelf Life In Days,Okres przydatności do spożycia w dniach,
-End of Life,Zakończenie okresu eksploatacji,
-Default Material Request Type,Domyślnie Materiał Typ żądania,
-Valuation Method,Metoda wyceny,
-FIFO,FIFO,
-Moving Average,Średnia Ruchoma,
-Warranty Period (in days),Okres gwarancji (w dniach),
-Auto re-order,Automatyczne ponowne zamówienie,
-Reorder level based on Warehouse,Zmiana kolejności w oparciu o poziom Magazynu,
-Will also apply for variants unless overrridden,"Również zostanie zastosowany do wariantów, chyba że zostanie nadpisany",
-Units of Measure,Jednostki miary,
-Will also apply for variants,Również zastosowanie do wariantów,
-Serial Nos and Batches,Numery seryjne i partie,
-Has Batch No,Posada numer partii (batch),
-Automatically Create New Batch,Automatyczne tworzenie nowych partii,
-Batch Number Series,Seria numerów partii,
-"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.","Przykład: ABCD. #####. Jeśli seria jest ustawiona, a numer partii nie jest wymieniony w transakcjach, na podstawie tej serii zostanie utworzony automatyczny numer partii. Jeśli zawsze chcesz wyraźnie podać numer partii dla tego produktu, pozostaw to pole puste. Uwaga: to ustawienie ma pierwszeństwo przed prefiksem serii nazw w Ustawieniach fotografii.",
-Has Expiry Date,Ma datę wygaśnięcia,
-Retain Sample,Zachowaj próbkę,
-Max Sample Quantity,Maksymalna ilość próbki,
-Maximum sample quantity that can be retained,"Maksymalna ilość próbki, którą można zatrzymać",
-Has Serial No,Posiada numer seryjny,
-Serial Number Series,Seria nr seryjnego,
-"Example: ABCD.#####\nIf series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Przykład:. ABCD ##### \n Jeśli seria jest ustawiona i nr seryjny nie jest wymieniony w transakcjach, automatyczny numer seryjny zostanie utworzony na podstawie tej serii. Jeśli chcesz zawsze jednoznacznie ustawiać numery seryjne dla tej pozycji, pozostaw to pole puste.",
-Variants,Warianty,
-Has Variants,Ma Warianty,
-"If this item has variants, then it cannot be selected in sales orders etc.","Jeśli ten element ma warianty, to nie może być wybrany w zleceniach sprzedaży itp",
-Variant Based On,Wariant na podstawie,
-Item Attribute,Atrybut elementu,
-"Sales, Purchase, Accounting Defaults","Sprzedaż, zakup, domyślne ustawienia rachunkowości",
-Item Defaults,Domyślne elementy,
-"Purchase, Replenishment Details","Zakup, szczegóły uzupełnienia",
-Is Purchase Item,Jest pozycją kupowalną,
-Default Purchase Unit of Measure,Domyślna jednostka miary zakupów,
-Minimum Order Qty,Minimalna wartość zamówienia,
-Minimum quantity should be as per Stock UOM,Minimalna ilość powinna być zgodna z magazynową jednostką organizacyjną,
-Average time taken by the supplier to deliver,Średni czas podjęte przez dostawcę do dostarczenia,
-Is Customer Provided Item,Jest przedmiotem dostarczonym przez klienta,
-Delivered by Supplier (Drop Ship),Dostarczane przez Dostawcę (Drop Ship),
-Supplier Items,Dostawca przedmioty,
-Foreign Trade Details,Handlu Zagranicznego Szczegóły,
-Country of Origin,Kraj pochodzenia,
-Sales Details,Szczegóły sprzedaży,
-Default Sales Unit of Measure,Domyślna jednostka sprzedaży środka,
-Is Sales Item,Jest pozycją sprzedawalną,
-Max Discount (%),Maksymalny rabat (%),
-No of Months,Liczba miesięcy,
-Customer Items,Pozycje klientów,
-Inspection Criteria,Kryteria kontrolne,
-Inspection Required before Purchase,Wymagane Kontrola przed zakupem,
-Inspection Required before Delivery,Wymagane Kontrola przed dostawą,
-Default BOM,Domyślne Zestawienie Materiałów,
-Supply Raw Materials for Purchase,Dostawa surowce Skupu,
-If subcontracted to a vendor,Jeśli zlecona dostawcy,
-Customer Code,Kod Klienta,
-Default Item Manufacturer,Domyślny producent pozycji,
-Default Manufacturer Part No,Domyślny numer części producenta,
-Show in Website (Variant),Pokaż w Serwisie (Variant),
-Items with higher weightage will be shown higher,Produkty z wyższym weightage zostaną pokazane wyższe,
-Show a slideshow at the top of the page,Pokazuj slideshow na górze strony,
-Website Image,Obraz strony internetowej,
-Website Warehouse,Magazyn strony WWW,
-"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Pokazuj ""W magazynie"" lub ""Brak w magazynie"" bazując na ilości dostępnej w tym magazynie.",
-Website Item Groups,Grupy przedmiotów strony WWW,
-List this Item in multiple groups on the website.,Pokaż ten produkt w wielu grupach na stronie internetowej.,
-Copy From Item Group,Skopiuj z Grupy Przedmiotów,
-Website Content,Zawartość strony internetowej,
-You can use any valid Bootstrap 4 markup in this field. It will be shown on your Item Page.,Możesz użyć dowolnego poprawnego znacznika Bootstrap 4 w tym polu. Zostanie on wyświetlony na Twojej stronie przedmiotu.,
-Total Projected Qty,Łącznej prognozowanej szt,
-Hub Publishing Details,Szczegóły publikacji wydawnictwa Hub,
-Publish in Hub,Publikowanie w Hub,
-Publish Item to hub.erpnext.com,Publikacja na hub.erpnext.com,
-Hub Category to Publish,Kategoria ośrodka do opublikowania,
-Hub Warehouse,Magazyn Hub,
-"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Opublikuj &quot;W magazynie&quot; lub &quot;Nie w magazynie&quot; w Hub na podstawie zapasów dostępnych w tym magazynie.,
-Synced With Hub,Synchronizowane z Hub,
-Item Alternative,Pozycja alternatywna,
-Alternative Item Code,Alternatywny kod towaru,
-Two-way,Dwukierunkowy,
-Alternative Item Name,Alternatywna nazwa przedmiotu,
-Attribute Name,Nazwa atrybutu,
-Numeric Values,Wartości liczbowe,
-From Range,Od zakresu,
-Increment,Przyrost,
-To Range,Do osiągnięcia,
-Item Attribute Values,Wartości atrybutu elementu,
-Item Attribute Value,Pozycja wartość atrybutu,
-Attribute Value,Wartość atrybutu,
-Abbreviation,Skrót,
-"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","To będzie dołączany do Kodeksu poz wariantu. Na przykład, jeśli skrót to ""SM"", a kod element jest ""T-SHIRT"" Kod poz wariantu będzie ""T-SHIRT-SM""",
-Item Barcode,Kod kreskowy,
-Barcode Type,Typ kodu kreskowego,
-EAN,EAN,
-UPC-A,UPC-A,
-Item Customer Detail,Element Szczegóły klienta,
-"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Dla wygody klientów, te kody mogą być użyte w formacie drukowania jak faktury czy dowody dostawy",
-Ref Code,Ref kod,
-Item Default,Domyślny produkt,
-Purchase Defaults,Zakup domyślne,
-Default Buying Cost Center,Domyślne Centrum Kosztów Kupowania,
-Default Supplier,Domyślny dostawca,
-Default Expense Account,Domyślne konto rozchodów,
-Sales Defaults,Domyślne wartości sprzedaży,
-Default Selling Cost Center,Domyślne centrum kosztów sprzedaży,
-Item Manufacturer,pozycja Producent,
-Item Price,Cena,
-Packing Unit,Jednostka pakująca,
-Quantity  that must be bought or sold per UOM,"Ilość, która musi zostać kupiona lub sprzedana za MOM",
-Item Quality Inspection Parameter,Element Parametr Inspekcja Jakości,
-Acceptance Criteria,Kryteria akceptacji,
-Item Reorder,Element Zamów ponownie,
-Check in (group),Przyjazd (grupa),
-Request for,Wniosek o,
-Re-order Level,Próg ponowienia zamówienia,
-Re-order Qty,Ilość w ponowieniu zamówienia,
-Item Supplier,Dostawca,
-Item Variant,Pozycja Wersja,
-Item Variant Attribute,Pozycja Wersja Atrybut,
-Do not update variants on save,Nie aktualizuj wariantów przy zapisie,
-Fields will be copied over only at time of creation.,Pola będą kopiowane tylko w momencie tworzenia.,
-Allow Rename Attribute Value,Zezwalaj na zmianę nazwy wartości atrybutu,
-Rename Attribute Value in Item Attribute.,Zmień nazwę atrybutu w atrybucie elementu.,
-Copy Fields to Variant,Skopiuj pola do wariantu,
-Item Website Specification,Element Specyfikacja Strony,
-Table for Item that will be shown in Web Site,"Tabela dla pozycji, które zostaną pokazane w Witrynie",
-Landed Cost Item,Koszt Przedmiotu,
-Receipt Document Type,Otrzymanie Rodzaj dokumentu,
-Receipt Document,Otrzymanie dokumentu,
-Applicable Charges,Obowiązujące opłaty,
-Purchase Receipt Item,Przedmiot Potwierdzenia Zakupu,
-Landed Cost Purchase Receipt,Koszt kupionego przedmiotu,
-Landed Cost Taxes and Charges,Koszt podatków i opłat,
-Landed Cost Voucher,Koszt kuponu,
-MAT-LCV-.YYYY.-,MAT-LCV-.YYYY.-,
-Purchase Receipts,Potwierdzenia Zakupu,
-Purchase Receipt Items,Przedmioty Potwierdzenia Zakupu,
-Get Items From Purchase Receipts,Uzyskaj pozycje z potwierdzeń zakupu.,
-Distribute Charges Based On,Rozpowszechnianie opłat na podstawie,
-Landed Cost Help,Ugruntowany Koszt Pomocy,
-Manufacturers used in Items,Producenci używane w pozycji,
-Limited to 12 characters,Ograniczona do 12 znaków,
-MAT-MR-.YYYY.-,MAT-MR-.RRRR.-,
-Partially Ordered,Częściowo zamówione,
-Transferred,Przeniesiony,
-% Ordered,% Zamówione,
-Terms and Conditions Content,Zawartość regulaminu,
-Quantity and Warehouse,Ilość i magazyn,
-Lead Time Date,Termin realizacji,
-Min Order Qty,Min. wartość zamówienia,
-Packed Item,Przedmiot pakowany,
-To Warehouse (Optional),Aby Warehouse (opcjonalnie),
-Actual Batch Quantity,Rzeczywista ilość partii,
-Prevdoc DocType,Typ dokumentu dla poprzedniego dokumentu,
-Parent Detail docname,Nazwa dokumentu ze szczegółami nadrzędnego rodzica,
-"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Utwórz paski na opakowania do dostawy. Używane do informacji o numerze opakowania, zawartości i wadze.",
-Indicates that the package is a part of this delivery (Only Draft),"Wskazuje, że pakiet jest częścią tej dostawy (Tylko projektu)",
-MAT-PAC-.YYYY.-,MAT-PAC-.YYYY.-,
-From Package No.,Nr Przesyłki,
-Identification of the package for the delivery (for print),Nr identyfikujący paczkę do dostawy (do druku),
-To Package No.,Do zapakowania Nr,
-If more than one package of the same type (for print),Jeśli więcej niż jedna paczka tego samego typu (do druku),
-Package Weight Details,Informacje o wadze paczki,
-The net weight of this package. (calculated automatically as sum of net weight of items),Masa netto tego pakietu. (Obliczone automatycznie jako suma masy netto poszczególnych pozycji),
-Net Weight UOM,Jednostka miary wagi netto,
-Gross Weight,Waga brutto,
-The gross weight of the package. Usually net weight + packaging material weight. (for print),Waga brutto opakowania. Zazwyczaj waga netto + waga materiału z jakiego jest wykonane opakowanie. (Do druku),
-Gross Weight UOM,Waga brutto Jednostka miary,
-Packing Slip Item,Pozycja listu przewozowego,
-DN Detail,,
-STO-PICK-.YYYY.-,STO-PICK-.YYYY.-,
-Material Transfer for Manufacture,Materiał transferu dla Produkcja,
-Qty of raw materials will be decided based on the qty of the Finished Goods Item,Ilość surowców zostanie ustalona na podstawie ilości produktu gotowego,
-Parent Warehouse,Dominująca Magazyn,
-Items under this warehouse will be suggested,Produkty w tym magazynie zostaną zasugerowane,
-Get Item Locations,Uzyskaj lokalizacje przedmiotów,
-Item Locations,Lokalizacje przedmiotów,
-Pick List Item,Wybierz element listy,
-Picked Qty,Wybrano ilość,
-Price List Master,Ustawienia Cennika,
-Price List Name,Nazwa cennika,
-Price Not UOM Dependent,Cena nie zależy od ceny,
-Applicable for Countries,Zastosowanie dla krajów,
-Price List Country,Cena Kraj,
-MAT-PRE-.YYYY.-,MAT-PRE-RAYY.-,
-Supplier Delivery Note,Uwagi do dostawy,
-Time at which materials were received,Data i czas otrzymania dostawy,
-Return Against Purchase Receipt,Powrót Przeciwko ZAKUPU,
-Rate at which supplier's currency is converted to company's base currency,Stawka przy użyciu której waluta dostawcy jest konwertowana do podstawowej waluty firmy,
-Sets 'Accepted Warehouse' in each row of the items table.,Ustawia „Zaakceptowany magazyn” w każdym wierszu tabeli towarów.,
-Sets 'Rejected Warehouse' in each row of the items table.,Ustawia „Magazyn odrzucony” w każdym wierszu tabeli towarów.,
-Raw Materials Consumed,Zużyte surowce,
-Get Current Stock,Pobierz aktualny stan magazynowy,
-Consumed Items,Zużyte przedmioty,
-Add / Edit Taxes and Charges,,
-Auto Repeat Detail,Auto Repeat Detail,
-Transporter Details,Szczegóły transportu,
-Vehicle Number,Numer pojazdu,
-Vehicle Date,Pojazd Data,
-Received and Accepted,Otrzymano i zaakceptowano,
-Accepted Quantity,Przyjęta Ilość,
-Rejected Quantity,Odrzucona Ilość,
-Accepted Qty as per Stock UOM,Zaakceptowana ilość zgodnie z JM zapasów,
-Sample Quantity,Ilość próbki,
-Rate and Amount,Stawka i Ilość,
-MAT-QA-.YYYY.-,MAT-QA-.YYYY.-,
-Report Date,Data raportu,
-Inspection Type,Typ kontroli,
-Item Serial No,Nr seryjny,
-Sample Size,Wielkość próby,
-Inspected By,Skontrolowane przez,
-Readings,Odczyty,
-Quality Inspection Reading,Odczyt kontroli jakości,
-Reading 1,Odczyt 1,
-Reading 2,Odczyt 2,
-Reading 3,Odczyt 3,
-Reading 4,Odczyt 4,
-Reading 5,Odczyt 5,
-Reading 6,Odczyt 6,
-Reading 7,Odczyt 7,
-Reading 8,Odczyt 8,
-Reading 9,Odczyt 9,
-Reading 10,Odczyt 10,
-Quality Inspection Template Name,Nazwa szablonu kontroli jakości,
-Quick Stock Balance,Szybkie saldo zapasów,
-Available Quantity,Dostępna Ilość,
-Distinct unit of an Item,Odrębna jednostka przedmiotu,
-Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Magazyn może być tylko zmieniony poprzez Wpis Asortymentu / Notę Dostawy / Potwierdzenie zakupu,
-Purchase / Manufacture Details,Szczegóły Zakupu / Produkcji,
-Creation Document Type,,
-Creation Document No,,
-Creation Date,Data utworzenia,
-Creation Time,Czas utworzenia,
-Asset Details,Szczegóły dotyczące aktywów,
-Asset Status,Status zasobu,
-Delivery Document Type,Typ dokumentu dostawy,
-Delivery Document No,Nr dokumentu dostawy,
-Delivery Time,Czas dostawy,
-Invoice Details,Dane do faktury,
-Warranty / AMC Details,Gwarancja / AMC Szczegóły,
-Warranty Expiry Date,Data upływu gwarancji,
-AMC Expiry Date,AMC Data Ważności,
-Under Warranty,Pod Gwarancją,
-Out of Warranty,Brak Gwarancji,
-Under AMC,Pod AMC,
-Out of AMC,,
-Warranty Period (Days),Okres gwarancji (dni),
-Serial No Details,Szczegóły numeru seryjnego,
-MAT-STE-.YYYY.-,MAT-STE-.YYYY.-,
-Stock Entry Type,Rodzaj wejścia na magazyn,
-Stock Entry (Outward GIT),Wjazd na giełdę (GIT zewnętrzny),
-Material Consumption for Manufacture,Zużycie materiału do produkcji,
-Repack,Przepakowanie,
-Send to Subcontractor,Wyślij do Podwykonawcy,
-Delivery Note No,Nr dowodu dostawy,
-Sales Invoice No,Nr faktury sprzedaży,
-Purchase Receipt No,Nr Potwierdzenia Zakupu,
-Inspection Required,Wymagana kontrola,
-From BOM,Od BOM,
-For Quantity,Dla Ilości,
-As per Stock UOM,,
-Including items for sub assemblies,W tym elementów dla zespołów sub,
-Default Source Warehouse,Domyślny magazyn źródłowy,
-Source Warehouse Address,Adres hurtowni,
-Default Target Warehouse,Domyślny magazyn docelowy,
-Target Warehouse Address,Docelowy adres hurtowni,
-Update Rate and Availability,Aktualizuj cenę i dostępność,
-Total Incoming Value,Całkowita wartość przychodów,
-Total Outgoing Value,Całkowita wartość wychodząca,
-Total Value Difference (Out - In),Całkowita Wartość Różnica (Out - In),
-Additional Costs,Dodatkowe koszty,
-Total Additional Costs,Wszystkich Dodatkowe koszty,
-Customer or Supplier Details,Szczegóły klienta lub dostawcy,
-Per Transferred,Na przeniesione,
-Stock Entry Detail,Szczególy zapisu magazynowego,
-Basic Rate (as per Stock UOM),Stawki podstawowej (zgodnie Stock UOM),
-Basic Amount,Kwota podstawowa,
-Additional Cost,Dodatkowy koszt,
-Serial No / Batch,Nr seryjny / partia,
-BOM No. for a Finished Good Item,,
-Material Request used to make this Stock Entry,,
-Subcontracted Item,Element podwykonawstwa,
-Against Stock Entry,Przeciwko wprowadzeniu akcji,
-Stock Entry Child,Dziecko do wejścia na giełdę,
-PO Supplied Item,PO Dostarczony przedmiot,
-Reference Purchase Receipt,Odbiór zakupu referencyjnego,
-Stock Ledger Entry,Zapis w księdze zapasów,
-Outgoing Rate,Wychodzące Cena,
-Actual Qty After Transaction,Rzeczywista Ilość Po Transakcji,
-Stock Value Difference,Różnica wartości zapasów,
-Stock Queue (FIFO),,
-Is Cancelled,,
-Stock Reconciliation,Uzgodnienia stanu,
-This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,To narzędzie pomaga uaktualnić lub ustalić ilość i wycenę akcji w systemie. To jest zwykle używany do synchronizacji wartości systemowych i co rzeczywiście istnieje w magazynach.,
-MAT-RECO-.YYYY.-,MAT-RECO-.RRRR.-,
-Reconciliation JSON,Wyrównywanie JSON,
-Stock Reconciliation Item,Uzgodnienia Stanu Pozycja,
-Before reconciliation,Przed pojednania,
-Current Serial No,Aktualny numer seryjny,
-Current Valuation Rate,Aktualny Wycena Cena,
-Current Amount,Aktualny Kwota,
-Quantity Difference,Ilość Różnica,
-Amount Difference,kwota różnicy,
-Item Naming By,Element Nazwy przez,
-Default Item Group,Domyślna grupa elementów,
-Default Stock UOM,Domyślna jednostka miary Asortymentu,
-Sample Retention Warehouse,Przykładowy magazyn retencyjny,
-Default Valuation Method,Domyślna metoda wyceny,
-Show Barcode Field,Pokaż pole kodu kreskowego,
-Convert Item Description to Clean HTML,"Konwertuj opis elementu, aby wyczyścić HTML",
-Allow Negative Stock,Dozwolony ujemny stan,
-Automatically Set Serial Nos based on FIFO,Nr seryjny automatycznie ustawiony w oparciu o FIFO,
-Auto Material Request,Zapytanie Auto Materiał,
-Inter Warehouse Transfer Settings,Ustawienia transferu między magazynami,
-Freeze Stock Entries,Zamroź Wpisy do Asortymentu,
-Stock Frozen Upto,Zamroź zapasy do,
-Batch Identification,Identyfikacja partii,
-Use Naming Series,Użyj serii nazw,
-Naming Series Prefix,Prefiks serii nazw,
-UOM Category,Kategoria UOM,
-UOM Conversion Detail,Szczegóły konwersji jednostki miary,
-Variant Field,Pole wariantu,
-A logical Warehouse against which stock entries are made.,Logiczny Magazyn przeciwny do zapisów.,
-Warehouse Detail,Szczegóły magazynu,
-Warehouse Name,Nazwa magazynu,
-Warehouse Contact Info,Dane kontaktowe dla magazynu,
-PIN,PIN,
-ISS-.YYYY.-,ISS-.YYYY.-,
-Raised By (Email),Wywołany przez (Email),
-Issue Type,rodzaj zagadnienia,
-Issue Split From,Wydanie Split From,
-Service Level,Poziom usług,
-Response By,Odpowiedź wg,
-Response By Variance,Odpowiedź według wariancji,
-Ongoing,Trwający,
-Resolution By,Rozdzielczość wg,
-Resolution By Variance,Rozdzielczość przez wariancję,
-Service Level Agreement Creation,Tworzenie umowy o poziomie usług,
-First Responded On,Data pierwszej odpowiedzi,
-Resolution Details,Szczegóły Rozstrzygnięcia,
-Opening Date,Data Otwarcia,
-Opening Time,Czas Otwarcia,
-Resolution Date,Data Rozstrzygnięcia,
-Via Customer Portal,Przez portal klienta,
-Support Team,Support Team,
-Issue Priority,Priorytet wydania,
-Service Day,Dzień obsługi,
-Workday,Dzień roboczy,
-Default Priority,Domyślny priorytet,
-Priorities,Priorytety,
-Support Hours,Godziny Wsparcia,
-Support and Resolution,Wsparcie i rozdzielczość,
-Default Service Level Agreement,Domyślna umowa o poziomie usług,
-Entity,Jednostka,
-Agreement Details,Szczegóły umowy,
-Response and Resolution Time,Czas odpowiedzi i rozdzielczości,
-Service Level Priority,Priorytet poziomu usług,
-Resolution Time,Czas rozdzielczości,
-Support Search Source,Wspieraj źródło wyszukiwania,
-Source Type,rodzaj źródła,
-Query Route String,Ciąg trasy zapytania,
-Search Term Param Name,Szukane słowo Nazwa Param,
-Response Options,Opcje odpowiedzi,
-Response Result Key Path,Kluczowa ścieżka odpowiedzi,
-Post Route String,Wpisz ciąg trasy,
-Post Route Key List,Opublikuj listę kluczy,
-Post Title Key,Post Title Key,
-Post Description Key,Klucz opisu postu,
-Link Options,Opcje linku,
-Source DocType,Źródło DocType,
-Result Title Field,Pole wyniku wyniku,
-Result Preview Field,Pole podglądu wyników,
-Result Route Field,Wynik Pole trasy,
-Service Level Agreements,Umowy o poziomie usług,
-Track Service Level Agreement,Śledź umowę o poziomie usług,
-Allow Resetting Service Level Agreement,Zezwalaj na resetowanie umowy o poziomie usług,
-Close Issue After Days,Po blisko Issue Dni,
-Auto close Issue after 7 days,Auto blisko Issue po 7 dniach,
-Support Portal,Portal wsparcia,
-Get Started Sections,Pierwsze kroki,
-Show Latest Forum Posts,Pokaż najnowsze posty na forum,
-Forum Posts,Posty na forum,
-Forum URL,URL forum,
-Get Latest Query,Pobierz najnowsze zapytanie,
-Response Key List,Lista kluczy odpowiedzi,
-Post Route Key,Wpisz klucz trasy,
-Search APIs,Wyszukaj interfejsy API,
-SER-WRN-.YYYY.-,SER-WRN-.RRRR.-,
-Issue Date,Data zdarzenia,
-Item and Warranty Details,Przedmiot i gwarancji Szczegóły,
-Warranty / AMC Status,Gwarancja / AMC Status,
-Resolved By,Rozstrzygnięte przez,
-Service Address,Adres usługi,
-If different than customer address,Jeśli jest inny niż adres klienta,
-Raised By,Wywołany przez,
-From Company,Od Firmy,
-Rename Tool,Zmień nazwę narzędzia,
-Utilities,Usługi komunalne,
-Type of document to rename.,"Typ dokumentu, którego zmieniasz nazwę",
-File to Rename,Plik to zmiany nazwy,
-"Attach .csv file with two columns, one for the old name and one for the new name","Dołączyć plik .csv z dwoma kolumnami, po jednym dla starej nazwy i jeden dla nowej nazwy",
-Rename Log,Zmień nazwę dziennika,
-SMS Log,Dziennik zdarzeń SMS,
-Sender Name,Nazwa Nadawcy,
-Sent On,Wysłano w,
-No of Requested SMS,Numer wymaganego SMS,
-Requested Numbers,Wymagane numery,
-No of Sent SMS,Numer wysłanego Sms,
-Sent To,Wysłane Do,
-Absent Student Report,Raport Nieobecności Studenta,
-Assessment Plan Status,Status planu oceny,
-Asset Depreciation Ledger,Księga amortyzacji,
-Asset Depreciations and Balances,Aktywów Amortyzacja i salda,
-Available Stock for Packing Items,Dostępne ilości dla materiałów opakunkowych,
-Bank Clearance Summary,Rozliczenia bankowe,
-Bank Remittance,Przelew bankowy,
-Batch Item Expiry Status,Batch Przedmiot status ważności,
-Batch-Wise Balance History,,
-BOM Explorer,Eksplorator BOM,
-BOM Search,BOM Szukaj,
-BOM Stock Calculated,BOM Stock Obliczono,
-BOM Variance Report,Raport wariancji BOM,
-Campaign Efficiency,Skuteczność Kampanii,
-Cash Flow,Przepływy pieniężne,
-Completed Work Orders,Zrealizowane zlecenia pracy,
-To Produce,Do produkcji,
-Produced,Wyprodukowany,
-Consolidated Financial Statement,Skonsolidowane sprawozdanie finansowe,
-Course wise Assessment Report,Szeregowy raport oceny,
-Customer Acquisition and Loyalty,,
-Customer Credit Balance,Saldo kredytowe klienta,
-Customer Ledger Summary,Podsumowanie księgi klienta,
-Customer-wise Item Price,Cena przedmiotu pod względem klienta,
-Customers Without Any Sales Transactions,Klienci bez żadnych transakcji sprzedaży,
-Daily Timesheet Summary,Codzienne grafiku Podsumowanie,
-Daily Work Summary Replies,Podsumowanie codziennej pracy,
-DATEV,DATEV,
-Delayed Item Report,Raport o opóźnionych przesyłkach,
-Delayed Order Report,Raport o opóźnionym zamówieniu,
-Delivered Items To Be Billed,Dostarczone przedmioty oczekujące na fakturowanie,
-Delivery Note Trends,Trendy Dowodów Dostawy,
-Electronic Invoice Register,Rejestr faktur elektronicznych,
-Employee Advance Summary,Podsumowanie zaliczek pracowników,
-Employee Billing Summary,Podsumowanie płatności dla pracowników,
-Employee Birthday,Data urodzenia pracownika,
-Employee Information,Informacja o pracowniku,
-Employee Leave Balance,Bilans Nieobecności Pracownika,
-Employee Leave Balance Summary,Podsumowanie salda urlopu pracownika,
-Employees working on a holiday,Pracownicy zatrudnieni na wakacje,
-Eway Bill,Eway Bill,
-Expiring Memberships,Wygaśnięcie członkostwa,
-Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC],
-Final Assessment Grades,Oceny końcowe,
-Fixed Asset Register,Naprawiono rejestr aktywów,
-Gross and Net Profit Report,Raport zysku brutto i netto,
-GST Itemised Purchase Register,GST Wykaz zamówień zakupu,
-GST Itemised Sales Register,Wykaz numerów sprzedaży produktów GST,
-GST Purchase Register,Rejestr zakupów GST,
-GST Sales Register,Rejestr sprzedaży GST,
-GSTR-1,GSTR-1,
-GSTR-2,GSTR-2,
-Hotel Room Occupancy,Pokój hotelowy,
-HSN-wise-summary of outward supplies,Podsumowanie HSN dostaw zewnętrznych,
-Inactive Customers,Nieaktywne Klienci,
-Inactive Sales Items,Nieaktywne elementy sprzedaży,
-IRS 1099,IRS 1099,
-Issued Items Against Work Order,Wydane przedmioty na zlecenie pracy,
-Projected Quantity as Source,Prognozowana ilość jako źródło,
-Item Balance (Simple),Bilans przedmiotu (prosty),
-Item Price Stock,Pozycja Cena towaru,
-Item Prices,Ceny,
-Item Shortage Report,Element Zgłoś Niedobór,
-Item Variant Details,Szczegóły wariantu przedmiotu,
-Item-wise Price List Rate,,
-Item-wise Purchase History,,
-Item-wise Purchase Register,,
-Item-wise Sales History,,
-Item-wise Sales Register,,
-Items To Be Requested,,
-Reserved,Zarezerwowany,
-Itemwise Recommended Reorder Level,Pozycja Zalecany poziom powtórnego zamówienia,
-Lead Details,Dane Tropu,
-Lead Owner Efficiency,Skuteczność właściciela wiodącego,
-Loan Repayment and Closure,Spłata i zamknięcie pożyczki,
-Loan Security Status,Status zabezpieczenia pożyczki,
-Lost Opportunity,Stracona szansa,
-Maintenance Schedules,Plany Konserwacji,
-Material Requests for which Supplier Quotations are not created,,
-Monthly Attendance Sheet,Miesięczna karta obecności,
-Open Work Orders,Otwórz zlecenia pracy,
-Qty to Deliver,Ilość do dostarczenia,
-Patient Appointment Analytics,Analiza wizyt pacjentów,
-Payment Period Based On Invoice Date,Termin Płatności oparty na dacie faktury,
-Pending SO Items For Purchase Request,Oczekiwane elementy Zamówień Sprzedaży na Prośbę Zakupu,
-Procurement Tracker,Śledzenie zamówień,
-Product Bundle Balance,Bilans pakietu produktów,
-Production Analytics,Analizy produkcyjne,
-Profit and Loss Statement,Rachunek zysków i strat,
-Profitability Analysis,Analiza rentowności,
-Project Billing Summary,Podsumowanie płatności za projekt,
-Project wise Stock Tracking,Śledzenie zapasów według projektu,
-Project wise Stock Tracking ,,
-Prospects Engaged But Not Converted,"Perspektywy zaręczone, ale nie przekształcone",
-Purchase Analytics,Analiza Zakupów,
-Purchase Invoice Trends,Trendy Faktur Zakupów,
-Qty to Receive,Ilość do otrzymania,
-Received Qty Amount,Otrzymana ilość,
-Billed Qty,Rozliczona ilość,
-Purchase Order Trends,Trendy Zamówienia Kupna,
-Purchase Receipt Trends,Trendy Potwierdzenia Zakupu,
-Purchase Register,Rejestracja Zakupu,
-Quotation Trends,Trendy Wyceny,
-Received Items To Be Billed,Otrzymane przedmioty czekające na zaksięgowanie,
-Qty to Order,Ilość do zamówienia,
-Requested Items To Be Transferred,Proszę o Przetranferowanie Przedmiotów,
-Qty to Transfer,Ilość do transferu,
-Salary Register,wynagrodzenie Rejestracja,
-Sales Analytics,Analityka sprzedaży,
-Sales Invoice Trends,,
-Sales Order Trends,,
-Sales Partner Commission Summary,Podsumowanie Komisji ds. Sprzedaży,
-Sales Partner Target Variance based on Item Group,Zmienna docelowa partnera handlowego na podstawie grupy pozycji,
-Sales Partner Transaction Summary,Podsumowanie transakcji partnera handlowego,
-Sales Partners Commission,Prowizja Partnera Sprzedaży,
-Invoiced Amount (Exclusive Tax),Kwota zafakturowana (bez podatku),
-Average Commission Rate,Średnia Prowizja,
-Sales Payment Summary,Podsumowanie płatności za sprzedaż,
-Sales Person Commission Summary,Osoba odpowiedzialna za sprzedaż,
-Sales Person Target Variance Based On Item Group,Zmienna docelowa osoby sprzedaży na podstawie grupy pozycji,
-Sales Person-wise Transaction Summary,,
-Sales Register,Rejestracja Sprzedaży,
-Serial No Service Contract Expiry,Umowa serwisowa o nr seryjnym wygasa,
-Serial No Status,Status nr seryjnego,
-Serial No Warranty Expiry,Gwarancja o nr seryjnym wygasa,
-Stock Ageing,Starzenie się zapasów,
-Stock and Account Value Comparison,Porównanie wartości zapasów i konta,
-Stock Projected Qty,Przewidywana ilość zapasów,
-Student and Guardian Contact Details,Uczeń i opiekun Dane kontaktowe,
-Student Batch-Wise Attendance,Partiami Student frekwencja,
-Student Fee Collection,Student Opłata Collection,
-Student Monthly Attendance Sheet,Student miesięczny Obecność Sheet,
-Subcontracted Item To Be Received,Przedmiot podwykonawstwa do odbioru,
-Subcontracted Raw Materials To Be Transferred,"Podwykonawstwo Surowce, które mają zostać przekazane",
-Supplier Ledger Summary,Podsumowanie księgi dostawców,
-Supplier-Wise Sales Analytics,,
-Support Hour Distribution,Dystrybucja godzin wsparcia,
-TDS Computation Summary,Podsumowanie obliczeń TDS,
-TDS Payable Monthly,Miesięczny płatny TDS,
-Territory Target Variance Based On Item Group,Territory Target Variance Based On Item Item,
-Territory-wise Sales,Sprzedaż terytorialna,
-Total Stock Summary,Całkowity podsumowanie zasobów,
-Trial Balance,Zestawienie obrotów i sald,
-Trial Balance (Simple),Bilans próbny (prosty),
-Trial Balance for Party,Trial Balance for Party,
-Unpaid Expense Claim,Niepłatny Koszty Zastrzeżenie,
-Warehouse wise Item Balance Age and Value,Magazyn mądry Pozycja Bilans Wiek i wartość,
-Work Order Stock Report,Raport o stanie zlecenia pracy,
-Work Orders in Progress,Zlecenia robocze w toku,
-Validation Error,Błąd walidacji,
-Automatically Process Deferred Accounting Entry,Automatycznie przetwarzaj odroczony zapis księgowy,
-Bank Clearance,Rozliczenie bankowe,
-Bank Clearance Detail,Szczegóły dotyczące rozliczeń bankowych,
-Update Cost Center Name / Number,Zaktualizuj nazwę / numer centrum kosztów,
-Journal Entry Template,Szablon wpisu do dziennika,
-Template Title,Tytuł szablonu,
-Journal Entry Type,Typ pozycji dziennika,
-Journal Entry Template Account,Konto szablonu zapisów księgowych,
-Process Deferred Accounting,Rozliczanie odroczone procesu,
-Manual entry cannot be created! Disable automatic entry for deferred accounting in accounts settings and try again,Nie można utworzyć ręcznego wpisu! Wyłącz automatyczne wprowadzanie odroczonych księgowań w ustawieniach kont i spróbuj ponownie,
-End date cannot be before start date,Data zakończenia nie może być wcześniejsza niż data rozpoczęcia,
-Total Counts Targeted,Łączna liczba docelowa,
-Total Counts Completed,Całkowita liczba zakończonych,
-Counts Targeted: {0},Docelowe liczby: {0},
-Payment Account is mandatory,Konto płatnicze jest obowiązkowe,
-"If checked, the full amount will be deducted from taxable income before calculating income tax without any declaration or proof submission.","Jeśli zaznaczone, pełna kwota zostanie odliczona od dochodu podlegającego opodatkowaniu przed obliczeniem podatku dochodowego bez składania deklaracji lub dowodów.",
-Disbursement Details,Szczegóły wypłaty,
-Material Request Warehouse,Magazyn żądań materiałowych,
-Select warehouse for material requests,Wybierz magazyn dla zapytań materiałowych,
-Transfer Materials For Warehouse {0},Przenieś materiały do magazynu {0},
-Production Plan Material Request Warehouse,Plan produkcji Magazyn żądań materiałowych,
-Sets 'Source Warehouse' in each row of the items table.,Ustawia „Magazyn źródłowy” w każdym wierszu tabeli towarów.,
-Sets 'Target Warehouse' in each row of the items table.,Ustawia „Magazyn docelowy” w każdym wierszu tabeli towarów.,
-Show Cancelled Entries,Pokaż anulowane wpisy,
-Backdated Stock Entry,Zapis akcji z datą wsteczną,
-Row #{}: Currency of {} - {} doesn't matches company currency.,Wiersz nr {}: waluta {} - {} nie odpowiada walucie firmy.,
-{} Assets created for {},{} Zasoby utworzone dla {},
-{0} Number {1} is already used in {2} {3},{0} Numer {1} jest już używany w {2} {3},
-Update Bank Clearance Dates,Zaktualizuj daty rozliczeń bankowych,
-Healthcare Practitioner: ,Lekarz:,
-Lab Test Conducted: ,Przeprowadzony test laboratoryjny:,
-Lab Test Event: ,Wydarzenie testów laboratoryjnych:,
-Lab Test Result: ,Wynik testu laboratoryjnego:,
-Clinical Procedure conducted: ,Przeprowadzona procedura kliniczna:,
-Therapy Session Charges: {0},Opłaty za sesję terapeutyczną: {0},
-Therapy: ,Terapia:,
-Therapy Plan: ,Plan terapii:,
-Total Counts Targeted: ,Łączna liczba docelowa:,
-Total Counts Completed: ,Łączna liczba zakończonych:,
-Andaman and Nicobar Islands,Wyspy Andaman i Nicobar,
-Andhra Pradesh,Andhra Pradesh,
-Arunachal Pradesh,Arunachal Pradesh,
-Assam,Assam,
-Bihar,Bihar,
-Chandigarh,Chandigarh,
-Chhattisgarh,Chhattisgarh,
-Dadra and Nagar Haveli,Dadra i Nagar Haveli,
-Daman and Diu,Daman i Diu,
-Delhi,Delhi,
-Goa,Goa,
-Gujarat,Gujarat,
-Haryana,Haryana,
-Himachal Pradesh,Himachal Pradesh,
-Jammu and Kashmir,Dżammu i Kaszmir,
-Jharkhand,Jharkhand,
-Karnataka,Karnataka,
-Kerala,Kerala,
-Lakshadweep Islands,Wyspy Lakshadweep,
-Madhya Pradesh,Madhya Pradesh,
-Maharashtra,Maharashtra,
-Manipur,Manipur,
-Meghalaya,Meghalaya,
-Mizoram,Mizoram,
-Nagaland,Nagaland,
-Odisha,Odisha,
-Other Territory,Inne terytorium,
-Pondicherry,Puducherry,
-Punjab,Pendżab,
-Rajasthan,Rajasthan,
-Sikkim,Sikkim,
-Tamil Nadu,Tamil Nadu,
-Telangana,Telangana,
-Tripura,Tripura,
-Uttar Pradesh,Uttar Pradesh,
-Uttarakhand,Uttarakhand,
-West Bengal,Bengal Zachodni,
-Is Mandatory,Jest obowiązkowe,
-Published on,Opublikowano,
-Service Received But Not Billed,"Usługa otrzymana, ale niezafakturowana",
-Deferred Accounting Settings,Odroczone ustawienia księgowania,
-Book Deferred Entries Based On,Rezerwuj wpisy odroczone na podstawie,
-Days,Dni,
-Months,Miesięcy,
-Book Deferred Entries Via Journal Entry,Rezerwuj wpisy odroczone za pośrednictwem wpisu do dziennika,
-Submit Journal Entries,Prześlij wpisy do dziennika,
-If this is unchecked Journal Entries will be saved in a Draft state and will have to be submitted manually,"Jeśli ta opcja nie jest zaznaczona, wpisy do dziennika zostaną zapisane jako wersja robocza i będą musiały zostać przesłane ręcznie",
-Enable Distributed Cost Center,Włącz rozproszone centrum kosztów,
-Distributed Cost Center,Rozproszone centrum kosztów,
-Dunning,Dunning,
-DUNN-.MM.-.YY.-,DUNN-.MM .-. YY.-,
-Overdue Days,Zaległe dni,
-Dunning Type,Typ monitu,
-Dunning Fee,Opłata za monitowanie,
-Dunning Amount,Kwota monitu,
-Resolved,Zdecydowany,
-Unresolved,Nie rozwiązany,
-Printing Setting,Ustawienie drukowania,
-Body Text,Body Text,
-Closing Text,Tekst zamykający,
-Resolve,Rozwiązać,
-Dunning Letter Text,Tekst listu monitującego,
-Is Default Language,Jest językiem domyślnym,
-Letter or Email Body Text,Treść listu lub wiadomości e-mail,
-Letter or Email Closing Text,List lub e-mail zamykający tekst,
-Body and Closing Text Help,Pomoc dotycząca treści i tekstu zamykającego,
-Overdue Interval,Zaległy interwał,
-Dunning Letter,List monitujący,
-"This section allows the user to set the Body and Closing text of the Dunning Letter for the Dunning Type based on language, which can be used in Print.","W tej sekcji użytkownik może ustawić treść i treść listu upominającego dla typu monitu w oparciu o język, którego można używać w druku.",
-Reference Detail No,Numer referencyjny odniesienia,
-Custom Remarks,Uwagi niestandardowe,
-Please select a Company first.,Najpierw wybierz firmę.,
-"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice, Journal Entry or Dunning","Wiersz nr {0}: typem dokumentu referencyjnego musi być zamówienie sprzedaży, faktura sprzedaży, zapis księgowy lub monit",
-POS Closing Entry,Zamknięcie POS,
-POS Opening Entry,Otwarcie POS,
-POS Transactions,Transakcje POS,
-POS Closing Entry Detail,Szczegóły wejścia zamknięcia POS,
-Opening Amount,Kwota otwarcia,
-Closing Amount,Kwota zamknięcia,
-POS Closing Entry Taxes,Podatki przy wejściu przy zamykaniu POS,
-POS Invoice,Faktura POS,
-ACC-PSINV-.YYYY.-,ACC-PSINV-.YYYY.-,
-Consolidated Sales Invoice,Skonsolidowana faktura sprzedaży,
-Return Against POS Invoice,Zwrot na podstawie faktury POS,
-Consolidated,Skonsolidowany,
-POS Invoice Item,Pozycja faktury POS,
-POS Invoice Merge Log,Dziennik scalania faktur POS,
-POS Invoices,Faktury POS,
-Consolidated Credit Note,Skonsolidowana nota kredytowa,
-POS Invoice Reference,Numer faktury POS,
-Set Posting Date,Ustaw datę księgowania,
-Opening Balance Details,Szczegóły salda otwarcia,
-POS Opening Entry Detail,Szczegóły wejścia do punktu sprzedaży,
-POS Payment Method,Metoda płatności POS,
-Payment Methods,Metody Płatności,
-Process Statement Of Accounts,Przetwarzaj wyciągi z kont,
-General Ledger Filters,Filtry księgi głównej,
-Customers,Klienci,
-Select Customers By,Wybierz klientów według,
-Fetch Customers,Pobierz klientów,
-Send To Primary Contact,Wyślij do głównej osoby kontaktowej,
-Print Preferences,Preferencje drukowania,
-Include Ageing Summary,Uwzględnij podsumowanie starzenia się,
-Enable Auto Email,Włącz automatyczne e-maile,
-Filter Duration (Months),Czas trwania filtra (miesiące),
-CC To,CC To,
-Help Text,Tekst pomocy,
-Emails Queued,E-maile w kolejce,
-Process Statement Of Accounts Customer,Przetwarzaj wyciąg z kont Klient,
-Billing Email,E-mail rozliczeniowy,
-Primary Contact Email,Adres e-mail głównej osoby kontaktowej,
-PSOA Cost Center,Centrum kosztów PSOA,
-PSOA Project,Projekt PSOA,
-ACC-PINV-RET-.YYYY.-,ACC-PINV-RET-.YYYY.-,
-Supplier GSTIN,Dostawca GSTIN,
-Place of Supply,Miejsce dostawy,
-Select Billing Address,Wybierz Adres rozliczeniowy,
-GST Details,Szczegóły dotyczące podatku GST,
-GST Category,Kategoria podatku GST,
-Registered Regular,Zarejestrowany Regularny,
-Registered Composition,Zarejestrowany skład,
-Unregistered,Niezarejestrowany,
-SEZ,SSE,
-Overseas,Za granicą,
-UIN Holders,Posiadacze UIN,
-With Payment of Tax,Z zapłatą podatku,
-Without Payment of Tax,Bez zapłaty podatku,
-Invoice Copy,Kopia faktury,
-Original for Recipient,Oryginał dla Odbiorcy,
-Duplicate for Transporter,Duplikat dla Transportera,
-Duplicate for Supplier,Duplikat dla dostawcy,
-Triplicate for Supplier,Potrójny egzemplarz dla dostawcy,
-Reverse Charge,Opłata zwrotna,
-Y,Y,
-N,N,
-E-commerce GSTIN,GSTIN dla handlu elektronicznego,
-Reason For Issuing document,Przyczyna wystawienia dokumentu,
-01-Sales Return,01-Zwrot sprzedaży,
-02-Post Sale Discount,02-zniżka po sprzedaży,
-03-Deficiency in services,03-Niedobór usług,
-04-Correction in Invoice,04-Korekta na fakturze,
-05-Change in POS,05-Zmiana w POS,
-06-Finalization of Provisional assessment,06-Zakończenie wstępnej oceny,
-07-Others,07-Inne,
-Eligibility For ITC,Kwalifikowalność do ITC,
-Input Service Distributor,Dystrybutor usług wejściowych,
-Import Of Service,Import usług,
-Import Of Capital Goods,Import dóbr kapitałowych,
-Ineligible,Którego nie można wybrać,
-All Other ITC,Wszystkie inne ITC,
-Availed ITC Integrated Tax,Dostępny podatek zintegrowany ITC,
-Availed ITC Central Tax,Zastosowany podatek centralny ITC,
-Availed ITC State/UT Tax,Dostępny podatek stanowy ITC / UT,
-Availed ITC Cess,Dostępny podatek ITC,
-Is Nil Rated or Exempted,Brak oceny lub zwolnienie,
-Is Non GST,Nie zawiera podatku GST,
-ACC-SINV-RET-.YYYY.-,ACC-SINV-RET-.YYYY.-,
-E-Way Bill No.,E-Way Bill No.,
-Is Consolidated,Jest skonsolidowane,
-Billing Address GSTIN,Adres rozliczeniowy GSTIN,
-Customer GSTIN,GSTIN klienta,
-GST Transporter ID,Identyfikator przewoźnika GST,
-Distance (in km),Odległość (w km),
-Road,Droga,
-Air,Powietrze,
-Rail,Szyna,
-Ship,Statek,
-GST Vehicle Type,Typ pojazdu z podatkiem VAT,
-Over Dimensional Cargo (ODC),Ładunki ponadwymiarowe (ODC),
-Consumer,Konsument,
-Deemed Export,Uważany za eksport,
-Port Code,Kod portu,
- Shipping Bill Number,Numer rachunku za wysyłkę,
-Shipping Bill Date,Data rachunku za wysyłkę,
-Subscription End Date,Data zakończenia subskrypcji,
-Follow Calendar Months,Śledź miesiące kalendarzowe,
-If this is checked subsequent new invoices will be created on calendar  month and quarter start dates irrespective of current invoice start date,"Jeśli ta opcja jest zaznaczona, kolejne nowe faktury będą tworzone w datach rozpoczęcia miesiąca kalendarzowego i kwartału, niezależnie od daty rozpoczęcia aktualnej faktury",
-Generate New Invoices Past Due Date,Wygeneruj nowe faktury przeterminowane,
-New invoices will be generated as per schedule even if current invoices are unpaid or past due date,"Nowe faktury będą generowane zgodnie z harmonogramem, nawet jeśli bieżące faktury są niezapłacone lub przeterminowane",
-Document Type ,typ dokumentu,
-Subscription Price Based On,Cena subskrypcji na podstawie,
-Fixed Rate,Stała stawka,
-Based On Price List,Na podstawie cennika,
-Monthly Rate,Opłata miesięczna,
-Cancel Subscription After Grace Period,Anuluj subskrypcję po okresie prolongaty,
-Source State,Stan źródłowy,
-Is Inter State,Jest międzystanowe,
-Purchase Details,Szczegóły zakupu,
-Depreciation Posting Date,Data księgowania amortyzacji,
-"By default, the Supplier Name is set as per the Supplier Name entered. If you want Suppliers to be named by a  ","Domyślnie nazwa dostawcy jest ustawiona zgodnie z wprowadzoną nazwą dostawcy. Jeśli chcesz, aby dostawcy byli nazwani przez rozszerzenie",
- choose the 'Naming Series' option.,wybierz opcję „Naming Series”.,
-Configure the default Price List when creating a new Purchase transaction. Item prices will be fetched from this Price List.,Skonfiguruj domyślny Cennik podczas tworzenia nowej transakcji zakupu. Ceny pozycji zostaną pobrane z tego Cennika.,
-"If this option is configured 'Yes', ERPNext will prevent you from creating a Purchase Invoice or Receipt without creating a Purchase Order first. This configuration can be overridden for a particular supplier by enabling the 'Allow Purchase Invoice Creation Without Purchase Order' checkbox in the Supplier master.","Jeśli ta opcja jest skonfigurowana jako „Tak”, ERPNext uniemożliwi utworzenie faktury zakupu lub paragonu bez wcześniejszego tworzenia zamówienia. Tę konfigurację można zastąpić dla określonego dostawcy, zaznaczając pole wyboru „Zezwalaj na tworzenie faktur zakupu bez zamówienia” w karcie głównej dostawcy.",
-"If this option is configured 'Yes', ERPNext will prevent you from creating a Purchase Invoice without creating a Purchase Receipt first. This configuration can be overridden for a particular supplier by enabling the 'Allow Purchase Invoice Creation Without Purchase Receipt' checkbox in the Supplier master.","Jeśli ta opcja jest skonfigurowana jako „Tak”, ERPNext uniemożliwi utworzenie faktury zakupu bez uprzedniego tworzenia paragonu zakupu. Tę konfigurację można zastąpić dla określonego dostawcy, zaznaczając pole wyboru „Zezwalaj na tworzenie faktur zakupu bez potwierdzenia zakupu” we wzorcu dostawcy.",
-Quantity & Stock,Ilość i stan magazynowy,
-Call Details,Szczegóły połączenia,
-Authorised By,Zaautoryzowany przez,
-Signee (Company),Signee (firma),
-Signed By (Company),Podpisane przez (firma),
-First Response Time,Czas pierwszej odpowiedzi,
-Request For Quotation,Zapytanie ofertowe,
-Opportunity Lost Reason Detail,Szczegóły utraconego powodu możliwości,
-Access Token Secret,Dostęp do klucza tajnego,
-Add to Topics,Dodaj do tematów,
-...Adding Article to Topics,... Dodawanie artykułu do tematów,
-Add Article to Topics,Dodaj artykuł do tematów,
-This article is already added to the existing topics,Ten artykuł jest już dodany do istniejących tematów,
-Add to Programs,Dodaj do programów,
-Programs,Programy,
-...Adding Course to Programs,... Dodawanie kursu do programów,
-Add Course to Programs,Dodaj kurs do programów,
-This course is already added to the existing programs,Ten kurs jest już dodany do istniejących programów,
-Learning Management System Settings,Ustawienia systemu zarządzania nauką,
-Enable Learning Management System,Włącz system zarządzania nauką,
-Learning Management System Title,Tytuł systemu zarządzania nauczaniem,
-...Adding Quiz to Topics,... Dodawanie quizu do tematów,
-Add Quiz to Topics,Dodaj quiz do tematów,
-This quiz is already added to the existing topics,Ten quiz został już dodany do istniejących tematów,
-Enable Admission Application,Włącz aplikację o przyjęcie,
-EDU-ATT-.YYYY.-,EDU-ATT-.YYYY.-,
-Marking attendance,Oznaczanie obecności,
-Add Guardians to Email Group,Dodaj opiekunów do grupy e-mailowej,
-Attendance Based On,Frekwencja na podstawie,
-Check this to mark the student as present in case the student is not attending the institute to participate or represent the institute in any event.\n\n,"Zaznacz to, aby oznaczyć ucznia jako obecnego na wypadek, gdyby student nie uczęszczał do instytutu, aby w żadnym wypadku uczestniczyć lub reprezentować instytut.",
-Add to Courses,Dodaj do kursów,
-...Adding Topic to Courses,... Dodawanie tematu do kursów,
-Add Topic to Courses,Dodaj temat do kursów,
-This topic is already added to the existing courses,Ten temat jest już dodany do istniejących kursów,
-"If Shopify does not have a customer in the order, then while syncing the orders, the system will consider the default customer for the order","Jeśli Shopify nie ma klienta w zamówieniu, to podczas synchronizacji zamówień system weźmie pod uwagę domyślnego klienta dla zamówienia",
-The accounts are set by the system automatically but do confirm these defaults,"Konta są ustawiane przez system automatycznie, ale potwierdzają te ustawienia domyślne",
-Default Round Off Account,Domyślne konto zaokrągleń,
-Failed Import Log,Nieudany import dziennika,
-Fixed Error Log,Naprawiono dziennik błędów,
-Company {0} already exists. Continuing will overwrite the Company and Chart of Accounts,Firma {0} już istnieje. Kontynuacja spowoduje nadpisanie firmy i planu kont,
-Meta Data,Metadane,
-Unresolve,Nierozwiązane,
-Create Document,Utwórz dokument,
-Mark as unresolved,Oznacz jako nierozwiązane,
-TaxJar Settings,Ustawienia TaxJar,
-Sandbox Mode,Tryb piaskownicy,
-Enable Tax Calculation,Włącz obliczanie podatku,
-Create TaxJar Transaction,Utwórz transakcję TaxJar,
-Credentials,Kwalifikacje,
-Live API Key,Aktywny klucz API,
-Sandbox API Key,Klucz API piaskownicy,
-Configuration,Konfiguracja,
-Tax Account Head,Szef konta podatkowego,
-Shipping Account Head,Szef konta wysyłkowego,
-Practitioner Name,Nazwisko lekarza,
-Enter a name for the Clinical Procedure Template,Wprowadź nazwę szablonu procedury klinicznej,
-Set the Item Code which will be used for billing the Clinical Procedure.,"Ustaw kod pozycji, który będzie używany do rozliczenia procedury klinicznej.",
-Select an Item Group for the Clinical Procedure Item.,Wybierz grupę pozycji dla pozycji procedury klinicznej.,
-Clinical Procedure Rate,Częstość zabiegów klinicznych,
-Check this if the Clinical Procedure is billable and also set the rate.,"Sprawdź, czy procedura kliniczna podlega opłacie, a także ustaw stawkę.",
-Check this if the Clinical Procedure utilises consumables. Click ,"Sprawdź to, jeśli procedura kliniczna wykorzystuje materiały eksploatacyjne. Kliknij",
- to know more,wiedzieć więcej,
-"You can also set the Medical Department for the template. After saving the document, an Item will automatically be created for billing this Clinical Procedure. You can then use this template while creating Clinical Procedures for Patients. Templates save you from filling up redundant data every single time. You can also create templates for other operations like Lab Tests, Therapy Sessions, etc.","Możesz również ustawić dział medyczny dla szablonu. Po zapisaniu dokumentu pozycja zostanie automatycznie utworzona do rozliczenia tej procedury klinicznej. Możesz następnie użyć tego szablonu podczas tworzenia procedur klinicznych dla pacjentów. Szablony chronią Cię przed zapełnianiem zbędnych danych za każdym razem. Możesz także tworzyć szablony dla innych operacji, takich jak testy laboratoryjne, sesje terapeutyczne itp.",
-Descriptive Test Result,Opisowy wynik testu,
-Allow Blank,Pozwól puste,
-Descriptive Test Template,Opisowy szablon testu,
-"If you want to track Payroll and other HRMS operations for a Practitoner, create an Employee and link it here.","Jeśli chcesz śledzić listę płac i inne operacje HRMS dla praktyka, utwórz pracownika i połącz go tutaj.",
-Set the Practitioner Schedule you just created. This will be used while booking appointments.,Ustaw właśnie utworzony harmonogram lekarza. Będzie on używany podczas rezerwacji spotkań.,
-Create a service item for Out Patient Consulting.,Utwórz pozycję usługi dla konsultacji z pacjentami zewnętrznymi.,
-"If this Healthcare Practitioner works for the In-Patient Department, create a service item for Inpatient Visits.","Jeśli ten pracownik służby zdrowia pracuje dla oddziału szpitalnego, utwórz pozycję usługi dla wizyt szpitalnych.",
-Set the Out Patient Consulting Charge for this Practitioner.,Ustaw opłatę za konsultacje pacjenta zewnętrznego dla tego lekarza.,
-"If this Healthcare Practitioner also works for the In-Patient Department, set the inpatient visit charge for this Practitioner.","Jeśli ten lekarz pracuje również dla oddziału szpitalnego, ustal opłatę za wizytę w szpitalu dla tego lekarza.",
-"If checked, a customer will be created for every Patient. Patient Invoices will be created against this Customer. You can also select existing Customer while creating a Patient. This field is checked by default.","Jeśli zaznaczone, dla każdego Pacjenta zostanie utworzony klient. Dla tego klienta zostaną utworzone faktury dla pacjenta. Możesz także wybrać istniejącego klienta podczas tworzenia pacjenta. To pole jest domyślnie zaznaczone.",
-Collect Registration Fee,Pobrać opłatę rejestracyjną,
-"If your Healthcare facility bills registrations of Patients, you can check this and set the Registration Fee in the field below. Checking this will create new Patients with a Disabled status by default and will only be enabled after invoicing the Registration Fee.","Jeśli Twoja placówka medyczna wystawia rachunki za rejestracje pacjentów, możesz to sprawdzić i ustawić Opłatę rejestracyjną w polu poniżej. Zaznaczenie tej opcji spowoduje domyślnie utworzenie nowych pacjentów ze statusem Wyłączony i będzie włączone dopiero po zafakturowaniu Opłaty rejestracyjnej.",
-Checking this will automatically create a Sales Invoice whenever an appointment is booked for a Patient.,"Zaznaczenie tego spowoduje automatyczne utworzenie faktury sprzedaży za każdym razem, gdy zostanie zarezerwowane spotkanie dla Pacjenta.",
-Healthcare Service Items,Elementy usług opieki zdrowotnej,
-"You can create a service item for Inpatient Visit Charge and set it here. Similarly, you can set up other Healthcare Service Items for billing in this section. Click ","Możesz utworzyć pozycję usługi dla opłaty za wizytę szpitalną i ustawić ją tutaj. Podobnie, w tej sekcji możesz skonfigurować inne pozycje usług opieki zdrowotnej do rozliczeń. Kliknij",
-Set up default Accounts for the Healthcare Facility,Skonfiguruj domyślne konta dla placówki opieki zdrowotnej,
-"If you wish to override default accounts settings and configure the Income and Receivable accounts for Healthcare, you can do so here.","Jeśli chcesz zastąpić domyślne ustawienia kont i skonfigurować konta dochodów i należności dla służby zdrowia, możesz to zrobić tutaj.",
-Out Patient SMS alerts,Alerty SMS dla pacjenta,
-"If you want to send SMS alert on Patient Registration, you can enable this option. Similary, you can set up Out Patient SMS alerts for other functionalities in this section. Click ","Jeśli chcesz wysłać powiadomienie SMS o rejestracji pacjenta, możesz włączyć tę opcję. Podobnie, w tej sekcji możesz skonfigurować alerty SMS dla pacjentów wychodzących dla innych funkcji. Kliknij",
-Admission Order Details,Szczegóły zlecenia przyjęcia,
-Admission Ordered For,Wstęp zamówiony dla,
-Expected Length of Stay,Oczekiwana długość pobytu,
-Admission Service Unit Type,Typ jednostki obsługi przyjęcia,
-Healthcare Practitioner (Primary),Lekarz (główna),
-Healthcare Practitioner (Secondary),Lekarz (średnia),
-Admission Instruction,Instrukcja przyjęcia,
-Chief Complaint,Główny zarzut,
-Medications,Leki,
-Investigations,Dochodzenia,
-Discharge Detials,Absolutorium Detials,
-Discharge Ordered Date,Data zamówienia wypisu,
-Discharge Instructions,Instrukcje dotyczące absolutorium,
-Follow Up Date,Data kontynuacji,
-Discharge Notes,Notatki absolutorium,
-Processing Inpatient Discharge,Przetwarzanie wypisu z szpitala,
-Processing Patient Admission,Przetwarzanie przyjęcia pacjenta,
-Check-in time cannot be greater than the current time,Czas zameldowania nie może być dłuższy niż aktualny czas,
-Process Transfer,Przetwarzanie transferu,
-HLC-LAB-.YYYY.-,HLC-LAB-.YYYY.-,
-Expected Result Date,Oczekiwana data wyniku,
-Expected Result Time,Oczekiwany czas wyniku,
-Printed on,Nadrukowany na,
-Requesting Practitioner,Praktykant,
-Requesting Department,Dział składania wniosków,
-Employee (Lab Technician),Pracownik (technik laboratoryjny),
-Lab Technician Name,Nazwisko technika laboratoryjnego,
-Lab Technician Designation,Oznaczenie technika laboratoryjnego,
-Compound Test Result,Wynik testu złożonego,
-Organism Test Result,Wynik testu organizmu,
-Sensitivity Test Result,Wynik testu wrażliwości,
-Worksheet Print,Drukuj arkusz roboczy,
-Worksheet Instructions,Instrukcje arkusza roboczego,
-Result Legend Print,Wydruk legendy wyników,
-Print Position,Pozycja drukowania,
-Bottom,Dolny,
-Top,Top,
-Both,Obie,
-Result Legend,Legenda wyników,
-Lab Tests,Testy laboratoryjne,
-No Lab Tests found for the Patient {0},Nie znaleziono testów laboratoryjnych dla pacjenta {0},
-"Did not send SMS, missing patient mobile number or message content.","Nie wysłano SMS-a, brak numeru telefonu komórkowego pacjenta lub treści wiadomości.",
-No Lab Tests created,Nie utworzono testów laboratoryjnych,
-Creating Lab Tests...,Tworzenie testów laboratoryjnych ...,
-Lab Test Group Template,Szablon grupy testów laboratoryjnych,
-Add New Line,Dodaj nową linię,
-Secondary UOM,Druga jednostka miary,
-"<b>Single</b>: Results which require only a single input.\n<br>\n<b>Compound</b>: Results which require multiple event inputs.\n<br>\n<b>Descriptive</b>: Tests which have multiple result components with manual result entry.\n<br>\n<b>Grouped</b>: Test templates which are a group of other test templates.\n<br>\n<b>No Result</b>: Tests with no results, can be ordered and billed but no Lab Test will be created. e.g.. Sub Tests for Grouped results","<b>Pojedynczy</b> : wyniki wymagające tylko jednego wprowadzenia.<br> <b>Złożone</b> : wyniki wymagające wielu wejść zdarzeń.<br> <b>Opisowe</b> : testy, które mają wiele składników wyników z ręcznym wprowadzaniem wyników.<br> <b>Zgrupowane</b> : szablony testów, które są grupą innych szablonów testów.<br> <b>Brak wyników</b> : Testy bez wyników można zamówić i zafakturować, ale nie zostaną utworzone żadne testy laboratoryjne. na przykład. Testy podrzędne dla wyników zgrupowanych",
-"If unchecked, the item will not be available in Sales Invoices for billing but can be used in group test creation. ","Jeśli odznaczone, pozycja nie będzie dostępna na fakturach sprzedaży do fakturowania, ale może być używana do tworzenia testów grupowych.",
-Description ,Opis,
-Descriptive Test,Test opisowy,
-Group Tests,Testy grupowe,
-Instructions to be printed on the worksheet,Instrukcje do wydrukowania w arkuszu,
-"Information to help easily interpret the test report, will be printed as part of the Lab Test result.",Informacje ułatwiające interpretację raportu z testu zostaną wydrukowane jako część wyniku testu laboratoryjnego.,
-Normal Test Result,Normalny wynik testu,
-Secondary UOM Result,Dodatkowy wynik UOM,
-Italic,italski,
-Underline,Podkreślać,
-Organism,Organizm,
-Organism Test Item,Przedmiot badania organizmu,
-Colony Population,Populacja kolonii,
-Colony UOM,Colony UOM,
-Tobacco Consumption (Past),Zużycie tytoniu (w przeszłości),
-Tobacco Consumption (Present),Zużycie tytoniu (obecne),
-Alcohol Consumption (Past),Spożycie alkoholu (w przeszłości),
-Alcohol Consumption (Present),Spożycie alkoholu (obecne),
-Billing Item,Pozycja rozliczeniowa,
-Medical Codes,Kody medyczne,
-Clinical Procedures,Procedury kliniczne,
-Order Admission,Zamów wstęp,
-Scheduling Patient Admission,Planowanie przyjęcia pacjenta,
-Order Discharge,Zamów rozładunek,
-Sample Details,Przykładowe szczegóły,
-Collected On,Zebrano dnia,
-No. of prints,Liczba wydruków,
-Number of prints required for labelling the samples,Liczba odbitek wymaganych do oznakowania próbek,
-HLC-VTS-.YYYY.-,HLC-VTS-.YYYY.-,
-In Time,W samą porę,
-Out Time,Out Time,
-Payroll Cost Center,Centrum kosztów listy płac,
-Approvers,Osoby zatwierdzające,
-The first Approver in the list will be set as the default Approver.,Pierwsza osoba zatwierdzająca na liście zostanie ustawiona jako domyślna osoba zatwierdzająca.,
-Shift Request Approver,Zatwierdzający prośbę o zmianę,
-PAN Number,Numer PAN,
-Provident Fund Account,Konto funduszu rezerwowego,
-MICR Code,Kod MICR,
-Repay unclaimed amount from salary,Zwróć nieodebraną kwotę z wynagrodzenia,
-Deduction from salary,Odliczenie od wynagrodzenia,
-Expired Leaves,Wygasłe liście,
-Reference No,Nr referencyjny,
-Haircut percentage is the percentage difference between market value of the Loan Security and the value ascribed to that Loan Security when used as collateral for that loan.,"Procent redukcji wartości to różnica procentowa między wartością rynkową Papieru Wartościowego Kredytu a wartością przypisaną temu Papierowi Wartościowemu Kredytowemu, gdy jest stosowany jako zabezpieczenie tej pożyczki.",
-Loan To Value Ratio expresses the ratio of the loan amount to the value of the security pledged. A loan security shortfall will be triggered if this falls below the specified value for any loan ,"Wskaźnik kredytu do wartości jest stosunkiem kwoty kredytu do wartości zastawionego zabezpieczenia. Niedobór zabezpieczenia pożyczki zostanie wyzwolony, jeśli spadnie poniżej określonej wartości dla jakiejkolwiek pożyczki",
-If this is not checked the loan by default will be considered as a Demand Loan,"Jeśli opcja ta nie zostanie zaznaczona, pożyczka domyślnie zostanie uznana za pożyczkę na żądanie",
-This account is used for booking loan repayments from the borrower and also disbursing loans to the borrower,"To konto służy do księgowania spłat pożyczki od pożyczkobiorcy, a także do wypłaty pożyczki pożyczkobiorcy",
-This account is capital account which is used to allocate capital for loan disbursal account ,"Rachunek ten jest rachunkiem kapitałowym, który służy do alokacji kapitału na rachunek wypłat pożyczki",
-This account will be used for booking loan interest accruals,To konto będzie używane do księgowania narosłych odsetek od kredytu,
-This account will be used for booking penalties levied due to delayed repayments,To konto będzie wykorzystywane do księgowania kar pobieranych z powodu opóźnionych spłat,
-Variant BOM,Wariant BOM,
-Template Item,Element szablonu,
-Select template item,Wybierz element szablonu,
-Select variant item code for the template item {0},Wybierz kod pozycji wariantu dla elementu szablonu {0},
-Downtime Entry,Wejście na czas przestoju,
-DT-,DT-,
-Workstation / Machine,Stacja robocza / maszyna,
-Operator,Operator,
-In Mins,W min,
-Downtime Reason,Przyczyna przestoju,
-Stop Reason,Stop Reason,
-Excessive machine set up time,Zbyt długi czas konfiguracji maszyny,
-Unplanned machine maintenance,Nieplanowana konserwacja maszyny,
-On-machine press checks,Kontrola prasy na maszynie,
-Machine operator errors,Błędy operatora maszyny,
-Machine malfunction,Awaria maszyny,
-Electricity down,Brak prądu,
-Operation Row Number,Numer wiersza operacji,
-Operation {0} added multiple times in the work order {1},Operacja {0} dodana wiele razy w zleceniu pracy {1},
-"If ticked, multiple materials can be used for a single Work Order. This is useful if one or more time consuming products are being manufactured.","Jeśli zaznaczone, w jednym zleceniu pracy można użyć wielu materiałów. Jest to przydatne, jeśli wytwarzany jest jeden lub więcej czasochłonnych produktów.",
-Backflush Raw Materials,Surowce do płukania wstecznego,
-"The Stock Entry of type 'Manufacture' is known as backflush. Raw materials being consumed to manufacture finished goods is known as backflushing. <br><br> When creating Manufacture Entry, raw-material items are backflushed based on BOM of production item. If you want raw-material items to be backflushed based on Material Transfer entry made against that Work Order instead, then you can set it under this field.","Wpis magazynowy typu „Produkcja” jest znany jako przepłukiwanie wsteczne. Surowce zużywane do produkcji wyrobów gotowych nazywa się płukaniem wstecznym.<br><br> Podczas tworzenia wpisu produkcji, pozycje surowców są przepłukiwane wstecznie na podstawie BOM pozycji produkcyjnej. Jeśli chcesz, aby pozycje surowców były wypłukiwane wstecznie na podstawie wpisu przeniesienia materiału dokonanego w ramach tego zlecenia pracy, możesz ustawić go w tym polu.",
-Work In Progress Warehouse,Magazyn Work In Progress,
-This Warehouse will be auto-updated in the Work In Progress Warehouse field of Work Orders.,Ten magazyn będzie automatycznie aktualizowany w polu Work In Progress Warehouse w Work Orders.,
-Finished Goods Warehouse,Magazyn Wyrobów Gotowych,
-This Warehouse will be auto-updated in the Target Warehouse field of Work Order.,Ten magazyn zostanie automatycznie zaktualizowany w polu Magazyn docelowy zlecenia pracy.,
-"If ticked, the BOM cost will be automatically updated based on Valuation Rate / Price List Rate / last purchase rate of raw materials.","Jeśli zaznaczone, koszt BOM zostanie automatycznie zaktualizowany na podstawie kursu wyceny / kursu cennika / ostatniego kursu zakupu surowców.",
-Source Warehouses (Optional),Magazyny źródłowe (opcjonalnie),
-"System will pickup the materials from the selected warehouses. If not specified, system will create material request for purchase.","System odbierze materiały z wybranych magazynów. Jeśli nie zostanie określony, system utworzy zapytanie o materiał do zakupu.",
-Lead Time,Czas oczekiwania,
-PAN Details,Szczegóły PAN,
-Create Customer,Utwórz klienta,
-Invoicing,Fakturowanie,
-Enable Auto Invoicing,Włącz automatyczne fakturowanie,
-Send Membership Acknowledgement,Wyślij potwierdzenie członkostwa,
-Send Invoice with Email,Wyślij fakturę e-mailem,
-Membership Print Format,Format wydruku członkostwa,
-Invoice Print Format,Format wydruku faktury,
-Revoke <Key></Key>,Unieważnić&lt;Key&gt;&lt;/Key&gt;,
-You can learn more about memberships in the manual. ,Więcej informacji na temat członkostwa można znaleźć w instrukcji.,
-ERPNext Docs,Dokumenty ERPNext,
-Regenerate Webhook Secret,Zregeneruj sekret Webhooka,
-Generate Webhook Secret,Wygeneruj klucz Webhook,
-Copy Webhook URL,Skopiuj adres URL webhooka,
-Linked Item,Powiązany element,
-Is Recurring,Powtarza się,
-HRA Exemption,Zwolnienie z HRA,
-Monthly House Rent,Miesięczny czynsz za dom,
-Rented in Metro City,Wynajęte w Metro City,
-HRA as per Salary Structure,HRA zgodnie ze strukturą wynagrodzeń,
-Annual HRA Exemption,Coroczne zwolnienie z HRA,
-Monthly HRA Exemption,Miesięczne zwolnienie z HRA,
-House Rent Payment Amount,Kwota spłaty czynszu za dom,
-Rented From Date,Wypożyczone od daty,
-Rented To Date,Wypożyczone do dnia,
-Monthly Eligible Amount,Kwota kwalifikowana miesięcznie,
-Total Eligible HRA Exemption,Całkowite kwalifikujące się zwolnienie z HRA,
-Validating Employee Attendance...,Weryfikacja obecności pracowników ...,
-Submitting Salary Slips and creating Journal Entry...,Przesyłanie odcinków wynagrodzenia i tworzenie zapisów księgowych ...,
-Calculate Payroll Working Days Based On,Oblicz dni robocze listy płac na podstawie,
-Consider Unmarked Attendance As,Rozważ nieoznaczoną obecność jako,
-Fraction of Daily Salary for Half Day,Część dziennego wynagrodzenia za pół dnia,
-Component Type,Typ komponentu,
-Provident Fund,Fundusz emerytalny,
-Additional Provident Fund,Dodatkowy fundusz emerytalny,
-Provident Fund Loan,Pożyczka z funduszu emerytalnego,
-Professional Tax,Podatek zawodowy,
-Is Income Tax Component,Składnik podatku dochodowego,
-Component properties and references ,Właściwości i odniesienia komponentów,
-Additional Salary ,Dodatkowe wynagrodzenie,
-Unmarked days,Nieoznakowane dni,
-Absent Days,Nieobecne dni,
-Conditions and Formula variable and example,Warunki i zmienna formuły oraz przykład,
-Feedback By,Informacje zwrotne od,
-Manufacturing Section,Sekcja Produkcyjna,
-"By default, the Customer Name is set as per the Full Name entered. If you want Customers to be named by a ","Domyślnie nazwa klienta jest ustawiona zgodnie z wprowadzoną pełną nazwą. Jeśli chcesz, aby klienci byli nazwani przez",
-Configure the default Price List when creating a new Sales transaction. Item prices will be fetched from this Price List.,Skonfiguruj domyślny Cennik podczas tworzenia nowej transakcji sprzedaży. Ceny pozycji zostaną pobrane z tego Cennika.,
-"If this option is configured 'Yes', ERPNext will prevent you from creating a Sales Invoice or Delivery Note without creating a Sales Order first. This configuration can be overridden for a particular Customer by enabling the 'Allow Sales Invoice Creation Without Sales Order' checkbox in the Customer master.","Jeśli ta opcja jest skonfigurowana jako „Tak”, ERPNext uniemożliwi utworzenie faktury sprzedaży lub dokumentu dostawy bez wcześniejszego tworzenia zamówienia sprzedaży. Tę konfigurację można zastąpić dla konkretnego klienta, zaznaczając pole wyboru „Zezwalaj na tworzenie faktur sprzedaży bez zamówienia sprzedaży” w karcie głównej Klient.",
-"If this option is configured 'Yes', ERPNext will prevent you from creating a Sales Invoice without creating a Delivery Note first. This configuration can be overridden for a particular Customer by enabling the 'Allow Sales Invoice Creation Without Delivery Note' checkbox in the Customer master.","Jeśli ta opcja jest skonfigurowana jako `` Tak &#39;&#39;, ERPNext uniemożliwi utworzenie faktury sprzedaży bez uprzedniego utworzenia dowodu dostawy. Tę konfigurację można zastąpić dla konkretnego klienta, zaznaczając pole wyboru „Zezwalaj na tworzenie faktur sprzedaży bez dowodu dostawy” we wzorcu klienta.",
-Default Warehouse for Sales Return,Domyślny magazyn do zwrotu sprzedaży,
-Default In Transit Warehouse,Domyślnie w magazynie tranzytowym,
-Enable Perpetual Inventory For Non Stock Items,Włącz ciągłe zapasy dla pozycji nie będących na stanie,
-HRA Settings,Ustawienia HRA,
-Basic Component,Element podstawowy,
-HRA Component,Komponent HRA,
-Arrear Component,Składnik zaległości,
-Please enter the company name to confirm,"Wprowadź nazwę firmy, aby potwierdzić",
-Quotation Lost Reason Detail,Szczegóły dotyczące utraconego powodu oferty,
-Enable Variants,Włącz warianty,
-Save Quotations as Draft,Zapisz oferty jako wersję roboczą,
-MAT-DN-RET-.YYYY.-,MAT-DN-RET-.YYYY.-,
-Please Select a Customer,Wybierz klienta,
-Against Delivery Note Item,Za list przewozowy,
-Is Non GST ,Nie zawiera podatku GST,
-Image Description,Opis obrazu,
-Transfer Status,Status transferu,
-MAT-PR-RET-.YYYY.-,MAT-PR-RET-.YYYY.-,
-Track this Purchase Receipt against any Project,Śledź ten dowód zakupu w dowolnym projekcie,
-Please Select a Supplier,Wybierz dostawcę,
-Add to Transit,Dodaj do transportu publicznego,
-Set Basic Rate Manually,Ustaw ręcznie stawkę podstawową,
-"By default, the Item Name is set as per the Item Code entered. If you want Items to be named by a ","Domyślnie nazwa pozycji jest ustawiona zgodnie z wprowadzonym kodem pozycji. Jeśli chcesz, aby elementy miały nazwę",
-Set a Default Warehouse for Inventory Transactions. This will be fetched into the Default Warehouse in the Item master.,Ustaw domyślny magazyn dla transakcji magazynowych. Zostanie to przeniesione do domyślnego magazynu w głównym module.,
-"This will allow stock items to be displayed in negative values. Using this option depends on your use case. With this option unchecked, the system warns before obstructing a transaction that is causing negative stock.","Umożliwi to wyświetlanie pozycji magazynowych w wartościach ujemnych. Korzystanie z tej opcji zależy od przypadku użycia. Gdy ta opcja jest odznaczona, system ostrzega przed zablokowaniem transakcji powodującej ujemny stan zapasów.",
-Choose between FIFO and Moving Average Valuation Methods. Click ,Wybierz metodę wyceny FIFO i ruchomą średnią wycenę. Kliknij,
- to know more about them.,aby dowiedzieć się o nich więcej.,
-Show 'Scan Barcode' field above every child table to insert Items with ease.,"Pokaż pole „Skanuj kod kreskowy” nad każdą tabelą podrzędną, aby z łatwością wstawiać elementy.",
-"Serial numbers for stock will be set automatically based on the Items entered based on first in first out in transactions like Purchase/Sales Invoices, Delivery Notes, etc.","Numery seryjne dla zapasów zostaną ustawione automatycznie na podstawie pozycji wprowadzonych w oparciu o pierwsze weszło pierwsze wyszło w transakcjach, takich jak faktury zakupu / sprzedaży, dowody dostawy itp.",
-"If blank, parent Warehouse Account or company default will be considered in transactions","Jeśli puste, nadrzędne konto magazynu lub wartość domyślna firmy będą brane pod uwagę w transakcjach",
-Service Level Agreement Details,Szczegóły umowy dotyczącej poziomu usług,
-Service Level Agreement Status,Status umowy dotyczącej poziomu usług,
-On Hold Since,Wstrzymane od,
-Total Hold Time,Całkowity czas wstrzymania,
-Response Details,Szczegóły odpowiedzi,
-Average Response Time,Średni czas odpowiedzi,
-User Resolution Time,Czas rozwiązania użytkownika,
-SLA is on hold since {0},Umowa SLA została wstrzymana od {0},
-Pause SLA On Status,Wstrzymaj status SLA,
-Pause SLA On,Wstrzymaj SLA,
-Greetings Section,Sekcja Pozdrowienia,
-Greeting Title,Tytuł powitania,
-Greeting Subtitle,Podtytuł powitania,
-Youtube ID,Identyfikator YouTube,
-Youtube Statistics,Statystyki YouTube,
-Views,Wyświetlenia,
-Dislikes,Nie lubi,
-Video Settings,Ustawienia wideo,
-Enable YouTube Tracking,Włącz śledzenie w YouTube,
-30 mins,30 minut,
-1 hr,1 godz,
-6 hrs,6 godz,
-Patient Progress,Postęp pacjenta,
-Targetted,Ukierunkowane,
-Score Obtained,Wynik uzyskany,
-Sessions,Sesje,
-Average Score,Średni wynik,
-Select Assessment Template,Wybierz szablon oceny,
- out of ,poza,
-Select Assessment Parameter,Wybierz parametr oceny,
-Gender: ,Płeć:,
-Contact: ,Kontakt:,
-Total Therapy Sessions: ,Sesje terapeutyczne:,
-Monthly Therapy Sessions: ,Comiesięczne sesje terapeutyczne:,
-Patient Profile,Profil pacjenta,
-Point Of Sale,Punkt sprzedaży,
-Email sent successfully.,E-mail wysłany pomyślnie.,
-Search by invoice id or customer name,Wyszukaj według identyfikatora faktury lub nazwy klienta,
-Invoice Status,Status faktury,
-Filter by invoice status,Filtruj według statusu faktury,
-Select item group,Wybierz grupę towarów,
-No items found. Scan barcode again.,Nie znaleziono żadnych przedmiotów. Ponownie zeskanuj kod kreskowy.,
-"Search by customer name, phone, email.","Szukaj według nazwy klienta, telefonu, adresu e-mail.",
-Enter discount percentage.,Wpisz procent rabatu.,
-Discount cannot be greater than 100%,Rabat nie może być większy niż 100%,
-Enter customer's email,Wpisz adres e-mail klienta,
-Enter customer's phone number,Wpisz numer telefonu klienta,
-Customer contact updated successfully.,Kontakt z klientem został zaktualizowany pomyślnie.,
-Item will be removed since no serial / batch no selected.,"Pozycja zostanie usunięta, ponieważ nie wybrano numeru seryjnego / partii.",
-Discount (%),Zniżka (%),
-You cannot submit the order without payment.,Nie możesz złożyć zamówienia bez zapłaty.,
-You cannot submit empty order.,Nie możesz złożyć pustego zamówienia.,
-To Be Paid,Do zapłacenia,
-Create POS Opening Entry,Utwórz wpis otwarcia POS,
-Please add Mode of payments and opening balance details.,Proszę dodać tryb płatności i szczegóły bilansu otwarcia.,
-Toggle Recent Orders,Przełącz ostatnie zamówienia,
-Save as Draft,Zapisz jako szkic,
-You must add atleast one item to save it as draft.,"Musisz dodać co najmniej jeden element, aby zapisać go jako wersję roboczą.",
-There was an error saving the document.,Wystąpił błąd podczas zapisywania dokumentu.,
-You must select a customer before adding an item.,Przed dodaniem pozycji musisz wybrać klienta.,
-Please Select a Company,Wybierz firmę,
-Active Leads,Aktywni leady,
-Please Select a Company.,Wybierz firmę.,
-BOM Operations Time,Czas operacji BOM,
-BOM ID,ID BOM,
-BOM Item Code,Kod pozycji BOM,
-Time (In Mins),Czas (w minutach),
-Sub-assembly BOM Count,Liczba BOM podzespołów,
-View Type,Typ widoku,
-Total Delivered Amount,Całkowita dostarczona kwota,
-Downtime Analysis,Analiza przestojów,
-Machine,Maszyna,
-Downtime (In Hours),Przestój (w godzinach),
-Employee Analytics,Analizy pracowników,
-"""From date"" can not be greater than or equal to ""To date""",„Data od” nie może być większa niż lub równa „Do dnia”,
-Exponential Smoothing Forecasting,Prognozowanie wygładzania wykładniczego,
-First Response Time for Issues,Czas pierwszej reakcji na problemy,
-First Response Time for Opportunity,Czas pierwszej reakcji na okazję,
-Depreciatied Amount,Kwota umorzona,
-Period Based On,Okres oparty na,
-Date Based On,Data na podstawie,
-{0} and {1} are mandatory,{0} i {1} są obowiązkowe,
-Consider Accounting Dimensions,Rozważ wymiary księgowe,
-Income Tax Deductions,Potrącenia podatku dochodowego,
-Income Tax Component,Składnik podatku dochodowego,
-Income Tax Amount,Kwota podatku dochodowego,
-Reserved Quantity for Production,Zarezerwowana ilość do produkcji,
-Projected Quantity,Prognozowana ilość,
- Total Sales Amount,Całkowita kwota sprzedaży,
-Job Card Summary,Podsumowanie karty pracy,
-Id,ID,
-Time Required (In Mins),Wymagany czas (w minutach),
-From Posting Date,Od daty księgowania,
-To Posting Date,Do daty wysłania,
-No records found,Nic nie znaleziono,
-Customer/Lead Name,Nazwa klienta / potencjalnego klienta,
-Unmarked Days,Nieoznaczone dni,
-Jan,Jan,
-Feb,Luty,
-Mar,Zniszczyć,
-Apr,Kwi,
-Aug,Sie,
-Sep,Wrz,
-Oct,Paź,
-Nov,Lis,
-Dec,Dec,
-Summarized View,Podsumowanie,
-Production Planning Report,Raport planowania produkcji,
-Order Qty,Zamówiona ilość,
-Raw Material Code,Kod surowca,
-Raw Material Name,Nazwa surowca,
-Allotted Qty,Przydzielona ilość,
-Expected Arrival Date,Oczekiwana data przyjazdu,
-Arrival Quantity,Ilość przybycia,
-Raw Material Warehouse,Magazyn surowców,
-Order By,Zamów przez,
-Include Sub-assembly Raw Materials,Uwzględnij surowce podzespołów,
-Professional Tax Deductions,Profesjonalne potrącenia podatkowe,
-Program wise Fee Collection,Programowe pobieranie opłat,
-Fees Collected,Pobrane opłaty,
-Project Summary,Podsumowanie projektu,
-Total Tasks,Całkowita liczba zadań,
-Tasks Completed,Zadania zakończone,
-Tasks Overdue,Zadania zaległe,
-Completion,Ukończenie,
-Provident Fund Deductions,Potrącenia z funduszu rezerwowego,
-Purchase Order Analysis,Analiza zamówienia,
-From and To Dates are required.,Wymagane są daty od i do.,
-To Date cannot be before From Date.,Data do nie może być wcześniejsza niż data początkowa.,
-Qty to Bill,Ilość do rachunku,
-Group by Purchase Order,Grupuj według zamówienia,
- Purchase Value,Wartość zakupu,
-Total Received Amount,Całkowita otrzymana kwota,
-Quality Inspection Summary,Podsumowanie kontroli jakości,
- Quoted Amount,Kwota podana,
-Lead Time (Days),Czas realizacji (dni),
-Include Expired,Uwzględnij wygasły,
-Recruitment Analytics,Analizy rekrutacyjne,
-Applicant name,Nazwa wnioskodawcy,
-Job Offer status,Status oferty pracy,
-On Date,Na randkę,
-Requested Items to Order and Receive,Żądane pozycje do zamówienia i odbioru,
-Salary Payments Based On Payment Mode,Płatności wynagrodzeń w zależności od trybu płatności,
-Salary Payments via ECS,Wypłaty wynagrodzenia za pośrednictwem ECS,
-Account No,Nr konta,
-IFSC,IFSC,
-MICR,MICR,
-Sales Order Analysis,Analiza zleceń sprzedaży,
-Amount Delivered,Dostarczona kwota,
-Delay (in Days),Opóźnienie (w dniach),
-Group by Sales Order,Grupuj według zamówienia sprzedaży,
- Sales Value,Wartość sprzedaży,
-Stock Qty vs Serial No Count,Ilość w magazynie a numer seryjny,
-Serial No Count,Numer seryjny,
-Work Order Summary,Podsumowanie zlecenia pracy,
-Produce Qty,Wyprodukuj ilość,
-Lead Time (in mins),Czas realizacji (w minutach),
-Charts Based On,Wykresy na podstawie,
-YouTube Interactions,Interakcje w YouTube,
-Published Date,Data publikacji,
-Barnch,Barnch,
-Select a Company,Wybierz firmę,
-Opportunity {0} created,Możliwość {0} została utworzona,
-Kindly select the company first,Najpierw wybierz firmę,
-Please enter From Date and To Date to generate JSON,"Wprowadź datę początkową i datę końcową, aby wygenerować JSON",
-PF Account,Konto PF,
-PF Amount,Kwota PF,
-Additional PF,Dodatkowe PF,
-PF Loan,Pożyczka PF,
-Download DATEV File,Pobierz plik DATEV,
-Numero has not set in the XML file,Numero nie ustawił w pliku XML,
-Inward Supplies(liable to reverse charge),Dostawy przychodzące (podlegające odwrotnemu obciążeniu),
-This is based on the course schedules of this Instructor,Jest to oparte na harmonogramach kursów tego instruktora,
-Course and Assessment,Kurs i ocena,
-Course {0} has been added to all the selected programs successfully.,Kurs {0} został pomyślnie dodany do wszystkich wybranych programów.,
-Programs updated,Programy zaktualizowane,
-Program and Course,Program i kurs,
-{0} or {1} is mandatory,{0} lub {1} jest obowiązkowe,
-Mandatory Fields,Pola obowiązkowe,
-Student {0}: {1} does not belong to Student Group {2},Student {0}: {1} nie należy do grupy uczniów {2},
-Student Attendance record {0} already exists against the Student {1},Rekord frekwencji {0} dla ucznia {1} już istnieje,
-Duplicate Entry,Zduplikowana wartość,
-Course and Fee,Kurs i opłata,
-Not eligible for the admission in this program as per Date Of Birth,Nie kwalifikuje się do przyjęcia w tym programie według daty urodzenia,
-Topic {0} has been added to all the selected courses successfully.,Temat {0} został pomyślnie dodany do wszystkich wybranych kursów.,
-Courses updated,Kursy zostały zaktualizowane,
-{0} {1} has been added to all the selected topics successfully.,Temat {0} {1} został pomyślnie dodany do wszystkich wybranych tematów.,
-Topics updated,Zaktualizowano tematy,
-Academic Term and Program,Okres akademicki i program,
-Please remove this item and try to submit again or update the posting time.,Usuń ten element i spróbuj przesłać go ponownie lub zaktualizuj czas publikacji.,
-Failed to Authenticate the API key.,Nie udało się uwierzytelnić klucza API.,
-Invalid Credentials,Nieprawidłowe dane logowania,
-URL can only be a string,URL może być tylko ciągiem,
-"Here is your webhook secret, this will be shown to you only once.","Oto Twój sekret webhooka, zostanie on pokazany tylko raz.",
-The payment for this membership is not paid. To generate invoice fill the payment details,Opłata za to członkostwo nie jest opłacana. Aby wygenerować fakturę wypełnij szczegóły płatności,
-An invoice is already linked to this document,Faktura jest już połączona z tym dokumentem,
-No customer linked to member {},Żaden klient nie jest powiązany z członkiem {},
-You need to set <b>Debit Account</b> in Membership Settings,Musisz ustawić <b>konto debetowe</b> w ustawieniach członkostwa,
-You need to set <b>Default Company</b> for invoicing in Membership Settings,Musisz ustawić <b>domyślną firmę</b> do fakturowania w ustawieniach członkostwa,
-You need to enable <b>Send Acknowledge Email</b> in Membership Settings,Musisz włączyć <b>wysyłanie wiadomości e-mail z potwierdzeniem</b> w ustawieniach członkostwa,
-Error creating membership entry for {0},Błąd podczas tworzenia wpisu członkowskiego dla {0},
-A customer is already linked to this Member,Klient jest już powiązany z tym członkiem,
-End Date must not be lesser than Start Date,Data zakończenia nie może być wcześniejsza niż data rozpoczęcia,
-Employee {0} already has Active Shift {1}: {2},Pracownik {0} ma już aktywną zmianę {1}: {2},
- from {0},od {0},
- to {0},do {0},
-Please select Employee first.,Najpierw wybierz pracownika.,
-Please set {0} for the Employee or for Department: {1},Ustaw {0} dla pracownika lub działu: {1},
-To Date should be greater than From Date,Data do powinna być większa niż Data początkowa,
-Employee Onboarding: {0} is already for Job Applicant: {1},Dołączanie pracowników: {0} jest już dla kandydatów o pracę: {1},
-Job Offer: {0} is already for Job Applicant: {1},Oferta pracy: {0} jest już dla osoby ubiegającej się o pracę: {1},
-Only Shift Request with status 'Approved' and 'Rejected' can be submitted,Można przesłać tylko żądanie zmiany ze statusem „Zatwierdzono” i „Odrzucono”,
-Shift Assignment: {0} created for Employee: {1},Przydział zmiany: {0} utworzony dla pracownika: {1},
-You can not request for your Default Shift: {0},Nie możesz zażądać zmiany domyślnej: {0},
-Only Approvers can Approve this Request.,Tylko osoby zatwierdzające mogą zatwierdzić tę prośbę.,
-Asset Value Analytics,Analiza wartości aktywów,
-Category-wise Asset Value,Wartość aktywów według kategorii,
-Total Assets,Aktywa ogółem,
-New Assets (This Year),Nowe zasoby (w tym roku),
-Row #{}: Depreciation Posting Date should not be equal to Available for Use Date.,Wiersz nr {}: Data księgowania amortyzacji nie powinna być równa dacie dostępności do użycia.,
-Incorrect Date,Nieprawidłowa data,
-Invalid Gross Purchase Amount,Nieprawidłowa kwota zakupu brutto,
-There are active maintenance or repairs against the asset. You must complete all of them before cancelling the asset.,Aktywna konserwacja lub naprawy są aktywne. Musisz je wszystkie wypełnić przed anulowaniem zasobu.,
-% Complete,% Ukończone,
-Back to Course,Powrót do kursu,
-Finish Topic,Zakończ temat,
-Mins,Min,
-by,przez,
-Back to,Wrócić do,
-Enrolling...,Rejestracja ...,
-You have successfully enrolled for the program ,Z powodzeniem zapisałeś się do programu,
-Enrolled,Zarejestrowany,
-Watch Intro,Obejrzyj wprowadzenie,
-We're here to help!,"Jesteśmy tutaj, aby pomóc!",
-Frequently Read Articles,Często czytane artykuły,
-Please set a default company address,Ustaw domyślny adres firmy,
-{0} is not a valid state! Check for typos or enter the ISO code for your state.,"{0} nie jest prawidłowym stanem! Sprawdź, czy nie ma literówek lub wprowadź kod ISO swojego stanu.",
-Error occured while parsing Chart of Accounts: Please make sure that no two accounts have the same name,"Wystąpił błąd podczas analizowania planu kont: upewnij się, że żadne dwa konta nie mają tej samej nazwy",
-Plaid invalid request error,Błąd żądania nieprawidłowego kratki,
-Please check your Plaid client ID and secret values,Sprawdź identyfikator klienta Plaid i tajne wartości,
-Bank transaction creation error,Błąd tworzenia transakcji bankowej,
-Unit of Measurement,Jednostka miary,
-Fiscal Year {0} Does Not Exist,Rok podatkowy {0} nie istnieje,
-Row # {0}: Returned Item {1} does not exist in {2} {3},Wiersz nr {0}: zwrócona pozycja {1} nie istnieje w {2} {3},
-Valuation type charges can not be marked as Inclusive,Opłaty związane z rodzajem wyceny nie mogą być oznaczone jako zawierające,
-You do not have permissions to {} items in a {}.,Nie masz uprawnień do {} elementów w {}.,
-Insufficient Permissions,Niewystarczające uprawnienia,
-You are not allowed to update as per the conditions set in {} Workflow.,Nie możesz aktualizować zgodnie z warunkami określonymi w {} Przepływie pracy.,
-Expense Account Missing,Brak konta wydatków,
-{0} is not a valid Value for Attribute {1} of Item {2}.,{0} nie jest prawidłową wartością atrybutu {1} elementu {2}.,
-Invalid Value,Niewłaściwa wartość,
-The value {0} is already assigned to an existing Item {1}.,Wartość {0} jest już przypisana do istniejącego elementu {1}.,
-"To still proceed with editing this Attribute Value, enable {0} in Item Variant Settings.","Aby nadal edytować tę wartość atrybutu, włącz opcję {0} w ustawieniach wariantu elementu.",
-Edit Not Allowed,Edycja niedozwolona,
-Row #{0}: Item {1} is already fully received in Purchase Order {2},Wiersz nr {0}: pozycja {1} jest już w całości otrzymana w zamówieniu {2},
-You cannot create or cancel any accounting entries with in the closed Accounting Period {0},Nie można tworzyć ani anulować żadnych zapisów księgowych w zamkniętym okresie rozliczeniowym {0},
-POS Invoice should have {} field checked.,Faktura POS powinna mieć zaznaczone pole {}.,
-Invalid Item,Nieprawidłowy przedmiot,
-Row #{}: You cannot add postive quantities in a return invoice. Please remove item {} to complete the return.,"Wiersz nr {}: nie można dodać ilości dodatnich do faktury zwrotnej. Usuń przedmiot {}, aby dokończyć zwrot.",
-The selected change account {} doesn't belongs to Company {}.,Wybrane konto zmiany {} nie należy do firmy {}.,
-Atleast one invoice has to be selected.,Należy wybrać przynajmniej jedną fakturę.,
-Payment methods are mandatory. Please add at least one payment method.,Metody płatności są obowiązkowe. Dodaj co najmniej jedną metodę płatności.,
-Please select a default mode of payment,Wybierz domyślny sposób płatności,
-You can only select one mode of payment as default,Możesz wybrać tylko jeden sposób płatności jako domyślny,
-Missing Account,Brakujące konto,
-Customers not selected.,Klienci nie wybrani.,
-Statement of Accounts,Wyciąg z konta,
-Ageing Report Based On ,Raport dotyczący starzenia na podstawie,
-Please enter distributed cost center,Wprowadź rozproszone centrum kosztów,
-Total percentage allocation for distributed cost center should be equal to 100,Całkowita alokacja procentowa dla rozproszonego centrum kosztów powinna wynosić 100,
-Cannot enable Distributed Cost Center for a Cost Center already allocated in another Distributed Cost Center,Nie można włączyć rozproszonego miejsca powstawania kosztów dla centrum kosztów już przydzielonego w innym rozproszonym miejscu kosztów,
-Parent Cost Center cannot be added in Distributed Cost Center,Nadrzędnego miejsca powstawania kosztów nie można dodać do rozproszonego miejsca powstawania kosztów,
-A Distributed Cost Center cannot be added in the Distributed Cost Center allocation table.,Nie można dodać Distributed Cost Center do tabeli alokacji Distributed Cost Center.,
-Cost Center with enabled distributed cost center can not be converted to group,Centrum kosztów z włączonym rozproszonym centrum kosztów nie może zostać przekonwertowane na grupę,
-Cost Center Already Allocated in a Distributed Cost Center cannot be converted to group,Centrum kosztów już alokowane w rozproszonym miejscu powstawania kosztów nie może zostać przekonwertowane na grupę,
-Trial Period Start date cannot be after Subscription Start Date,Data rozpoczęcia okresu próbnego nie może być późniejsza niż data rozpoczęcia subskrypcji,
-Subscription End Date must be after {0} as per the subscription plan,Data zakończenia subskrypcji musi przypadać po {0} zgodnie z planem subskrypcji,
-Subscription End Date is mandatory to follow calendar months,"Data zakończenia subskrypcji jest obowiązkowa, aby przestrzegać miesięcy kalendarzowych",
-Row #{}: POS Invoice {} is not against customer {},Wiersz nr {}: faktura POS {} nie jest skierowana przeciwko klientowi {},
-Row #{}: POS Invoice {} is not submitted yet,Wiersz nr {}: faktura POS {} nie została jeszcze przesłana,
-Row #{}: POS Invoice {} has been {},Wiersz nr {}: faktura POS {} została {},
-No Supplier found for Inter Company Transactions which represents company {0},Nie znaleziono dostawcy dla transakcji międzyfirmowych reprezentującego firmę {0},
-No Customer found for Inter Company Transactions which represents company {0},Nie znaleziono klienta dla transakcji międzyfirmowych reprezentującego firmę {0},
-Invalid Period,Nieprawidłowy okres,
-Selected POS Opening Entry should be open.,Wybrane wejście otwierające POS powinno być otwarte.,
-Invalid Opening Entry,Nieprawidłowy wpis otwierający,
-Please set a Company,Ustaw firmę,
-"Sorry, this coupon code's validity has not started","Przepraszamy, ważność tego kodu kuponu jeszcze się nie rozpoczęła",
-"Sorry, this coupon code's validity has expired","Przepraszamy, ważność tego kuponu wygasła",
-"Sorry, this coupon code is no longer valid","Przepraszamy, ten kod kuponu nie jest już ważny",
-For the 'Apply Rule On Other' condition the field {0} is mandatory,W przypadku warunku „Zastosuj regułę do innej” pole {0} jest obowiązkowe,
-{1} Not in Stock,{1} Niedostępny,
-Only {0} in Stock for item {1},Tylko {0} w magazynie dla produktu {1},
-Please enter a coupon code,Wprowadź kod kuponu,
-Please enter a valid coupon code,Wpisz prawidłowy kod kuponu,
-Invalid Child Procedure,Nieprawidłowa procedura podrzędna,
-Import Italian Supplier Invoice.,Import włoskiej faktury dostawcy.,
-"Valuation Rate for the Item {0}, is required to do accounting entries for {1} {2}.",Stawka wyceny dla przedmiotu {0} jest wymagana do zapisów księgowych dla {1} {2}.,
- Here are the options to proceed:,"Oto opcje, aby kontynuować:",
-"If the item is transacting as a Zero Valuation Rate item in this entry, please enable 'Allow Zero Valuation Rate' in the {0} Item table.","Jeśli przedmiot jest przedmiotem transakcji jako pozycja z zerową wartością wyceny w tym wpisie, włącz opcję „Zezwalaj na zerową stawkę wyceny” w {0} tabeli pozycji.",
-"If not, you can Cancel / Submit this entry ","Jeśli nie, możesz anulować / przesłać ten wpis",
- performing either one below:,wykonując jedną z poniższych czynności:,
-Create an incoming stock transaction for the Item.,Utwórz przychodzącą transakcję magazynową dla towaru.,
-Mention Valuation Rate in the Item master.,W głównym elemencie przedmiotu należy wspomnieć o współczynniku wyceny.,
-Valuation Rate Missing,Brak kursu wyceny,
-Serial Nos Required,Wymagane numery seryjne,
-Quantity Mismatch,Niedopasowanie ilości,
-"Please Restock Items and Update the Pick List to continue. To discontinue, cancel the Pick List.","Uzupełnij pozycje i zaktualizuj listę wyboru, aby kontynuować. Aby przerwać, anuluj listę wyboru.",
-Out of Stock,Obecnie brak na stanie,
-{0} units of Item {1} is not available.,{0} jednostki produktu {1} nie są dostępne.,
-Item for row {0} does not match Material Request,Pozycja w wierszu {0} nie pasuje do żądania materiału,
-Warehouse for row {0} does not match Material Request,Magazyn dla wiersza {0} nie jest zgodny z żądaniem materiałowym,
-Accounting Entry for Service,Wpis księgowy za usługę,
-All items have already been Invoiced/Returned,Wszystkie pozycje zostały już zafakturowane / zwrócone,
-All these items have already been Invoiced/Returned,Wszystkie te pozycje zostały już zafakturowane / zwrócone,
-Stock Reconciliations,Uzgodnienia zapasów,
-Merge not allowed,Scalanie niedozwolone,
-The following deleted attributes exist in Variants but not in the Template. You can either delete the Variants or keep the attribute(s) in template.,"Następujące usunięte atrybuty istnieją w wariantach, ale nie istnieją w szablonie. Możesz usunąć warianty lub zachować atrybut (y) w szablonie.",
-Variant Items,Elementy wariantowe,
-Variant Attribute Error,Błąd atrybutu wariantu,
-The serial no {0} does not belong to item {1},Numer seryjny {0} nie należy do produktu {1},
-There is no batch found against the {0}: {1},Nie znaleziono partii dla {0}: {1},
-Completed Operation,Operacja zakończona,
-Work Order Analysis,Analiza zlecenia pracy,
-Quality Inspection Analysis,Analiza kontroli jakości,
-Pending Work Order,Oczekujące zlecenie pracy,
-Last Month Downtime Analysis,Analiza przestojów w zeszłym miesiącu,
-Work Order Qty Analysis,Analiza ilości zleceń,
-Job Card Analysis,Analiza karty pracy,
-Monthly Total Work Orders,Miesięczne zamówienia łącznie,
-Monthly Completed Work Orders,Wykonane co miesiąc zamówienia,
-Ongoing Job Cards,Karty trwającej pracy,
-Monthly Quality Inspections,Comiesięczne kontrole jakości,
-(Forecast),(Prognoza),
-Total Demand (Past Data),Całkowity popyt (poprzednie dane),
-Total Forecast (Past Data),Prognoza całkowita (dane z przeszłości),
-Total Forecast (Future Data),Prognoza całkowita (dane przyszłe),
-Based On Document,Na podstawie dokumentu,
-Based On Data ( in years ),Na podstawie danych (w latach),
-Smoothing Constant,Stała wygładzania,
-Please fill the Sales Orders table,Prosimy o wypełnienie tabeli Zamówienia sprzedaży,
-Sales Orders Required,Wymagane zamówienia sprzedaży,
-Please fill the Material Requests table,Proszę wypełnić tabelę zamówień materiałowych,
-Material Requests Required,Wymagane żądania materiałów,
-Items to Manufacture are required to pull the Raw Materials associated with it.,Przedmioty do produkcji są zobowiązane do ściągnięcia związanych z nimi surowców.,
-Items Required,Wymagane elementy,
-Operation {0} does not belong to the work order {1},Operacja {0} nie należy do zlecenia pracy {1},
-Print UOM after Quantity,Drukuj UOM po Quantity,
-Set default {0} account for perpetual inventory for non stock items,Ustaw domyślne konto {0} dla ciągłych zapasów dla pozycji spoza magazynu,
-Loan Security {0} added multiple times,Bezpieczeństwo pożyczki {0} zostało dodane wiele razy,
-Loan Securities with different LTV ratio cannot be pledged against one loan,Dłużne Papiery Wartościowe o różnym wskaźniku LTV nie mogą być przedmiotem zastawu na jedną pożyczkę,
-Qty or Amount is mandatory for loan security!,Ilość lub kwota jest obowiązkowa dla zabezpieczenia kredytu!,
-Only submittted unpledge requests can be approved,Zatwierdzać można tylko przesłane żądania niezwiązane z próbą,
-Interest Amount or Principal Amount is mandatory,Kwota odsetek lub kwota główna jest obowiązkowa,
-Disbursed Amount cannot be greater than {0},Wypłacona kwota nie może być większa niż {0},
-Row {0}: Loan Security {1} added multiple times,Wiersz {0}: Bezpieczeństwo pożyczki {1} został dodany wiele razy,
-Row #{0}: Child Item should not be a Product Bundle. Please remove Item {1} and Save,Wiersz nr {0}: Element podrzędny nie powinien być pakietem produktów. Usuń element {1} i zapisz,
-Credit limit reached for customer {0},Osiągnięto limit kredytowy dla klienta {0},
-Could not auto create Customer due to the following missing mandatory field(s):,Nie można automatycznie utworzyć klienta z powodu następujących brakujących pól obowiązkowych:,
-Please create Customer from Lead {0}.,Utwórz klienta z potencjalnego klienta {0}.,
-Mandatory Missing,Obowiązkowy brak,
-Please set Payroll based on in Payroll settings,Ustaw listę płac na podstawie w ustawieniach listy płac,
-Additional Salary: {0} already exist for Salary Component: {1} for period {2} and {3},Dodatkowe wynagrodzenie: {0} już istnieje dla składnika wynagrodzenia: {1} za okres {2} i {3},
-From Date can not be greater than To Date.,Data początkowa nie może być większa niż data początkowa.,
-Payroll date can not be less than employee's joining date.,Data wypłaty nie może być wcześniejsza niż data przystąpienia pracownika.,
-From date can not be less than employee's joining date.,Data początkowa nie może być wcześniejsza niż data przystąpienia pracownika.,
-To date can not be greater than employee's relieving date.,Do tej pory nie może być późniejsza niż data zwolnienia pracownika.,
-Payroll date can not be greater than employee's relieving date.,Data wypłaty nie może być późniejsza niż data zwolnienia pracownika.,
-Row #{0}: Please enter the result value for {1},Wiersz nr {0}: wprowadź wartość wyniku dla {1},
-Mandatory Results,Obowiązkowe wyniki,
-Sales Invoice or Patient Encounter is required to create Lab Tests,Do tworzenia testów laboratoryjnych wymagana jest faktura sprzedaży lub spotkanie z pacjentami,
-Insufficient Data,Niedostateczna ilość danych,
-Lab Test(s) {0} created successfully,Test (y) laboratoryjne {0} zostały utworzone pomyślnie,
-Test :,Test:,
-Sample Collection {0} has been created,Utworzono zbiór próbek {0},
-Normal Range: ,Normalny zakres:,
-Row #{0}: Check Out datetime cannot be less than Check In datetime,Wiersz nr {0}: Data i godzina wyewidencjonowania nie może być mniejsza niż data i godzina wyewidencjonowania,
-"Missing required details, did not create Inpatient Record","Brak wymaganych szczegółów, nie utworzono rekordu pacjenta",
-Unbilled Invoices,Niezafakturowane faktury,
-Standard Selling Rate should be greater than zero.,Standardowa cena sprzedaży powinna być większa niż zero.,
-Conversion Factor is mandatory,Współczynnik konwersji jest obowiązkowy,
-Row #{0}: Conversion Factor is mandatory,Wiersz nr {0}: współczynnik konwersji jest obowiązkowy,
-Sample Quantity cannot be negative or 0,Ilość próbki nie może być ujemna ani 0,
-Invalid Quantity,Nieprawidłowa ilość,
-"Please set defaults for Customer Group, Territory and Selling Price List in Selling Settings","Ustaw wartości domyślne dla grupy klientów, terytorium i cennika sprzedaży w Ustawieniach sprzedaży",
-{0} on {1},{0} na {1},
-{0} with {1},{0} z {1},
-Appointment Confirmation Message Not Sent,Wiadomość z potwierdzeniem spotkania nie została wysłana,
-"SMS not sent, please check SMS Settings","SMS nie został wysłany, sprawdź ustawienia SMS",
-Healthcare Service Unit Type cannot have both {0} and {1},Typ jednostki usług opieki zdrowotnej nie może mieć jednocześnie {0} i {1},
-Healthcare Service Unit Type must allow atleast one among {0} and {1},Typ jednostki usług opieki zdrowotnej musi dopuszczać co najmniej jedną spośród {0} i {1},
-Set Response Time and Resolution Time for Priority {0} in row {1}.,Ustaw czas odpowiedzi i czas rozwiązania dla priorytetu {0} w wierszu {1}.,
-Response Time for {0} priority in row {1} can't be greater than Resolution Time.,Czas odpowiedzi dla {0} priorytetu w wierszu {1} nie może być dłuższy niż czas rozwiązania.,
-{0} is not enabled in {1},{0} nie jest włączony w {1},
-Group by Material Request,Grupuj według żądania materiału,
-Email Sent to Supplier {0},Wiadomość e-mail wysłana do dostawcy {0},
-"The Access to Request for Quotation From Portal is Disabled. To Allow Access, Enable it in Portal Settings.","Dostęp do zapytania ofertowego z portalu jest wyłączony. Aby zezwolić na dostęp, włącz go w ustawieniach portalu.",
-Supplier Quotation {0} Created,Oferta dostawcy {0} została utworzona,
-Valid till Date cannot be before Transaction Date,Data ważności do nie może być wcześniejsza niż data transakcji,
-Unlink Advance Payment on Cancellation of Order,Odłącz przedpłatę przy anulowaniu zamówienia,
-"Simple Python Expression, Example: territory != 'All Territories'","Proste wyrażenie w Pythonie, przykład: terytorium! = &#39;Wszystkie terytoria&#39;",
-Sales Contributions and Incentives,Składki na sprzedaż i zachęty,
-Sourced by Supplier,Źródło: Dostawca,
-Total weightage assigned should be 100%.<br>It is {0},Łączna przypisana waga powinna wynosić 100%.<br> To jest {0},
-Account {0} exists in parent company {1}.,Konto {0} istnieje w firmie macierzystej {1}.,
-"To overrule this, enable '{0}' in company {1}","Aby to zmienić, włącz „{0}” w firmie {1}",
-Invalid condition expression,Nieprawidłowe wyrażenie warunku,
-Please Select a Company First,Najpierw wybierz firmę,
-Please Select Both Company and Party Type First,Najpierw wybierz firmę i typ strony,
-Provide the invoice portion in percent,Podaj część faktury w procentach,
-Give number of days according to prior selection,Podaj liczbę dni według wcześniejszego wyboru,
-Email Details,Szczegóły wiadomości e-mail,
-"Select a greeting for the receiver. E.g. Mr., Ms., etc.","Wybierz powitanie dla odbiorcy. Np. Pan, Pani itp.",
-Preview Email,Podgląd wiadomości e-mail,
-Please select a Supplier,Wybierz dostawcę,
-Supplier Lead Time (days),Czas oczekiwania dostawcy (dni),
-"Home, Work, etc.","Dom, praca itp.",
-Exit Interview Held On,Zakończ rozmowę kwalifikacyjną wstrzymaną,
-Condition and formula,Stan i formuła,
-Sets 'Target Warehouse' in each row of the Items table.,Ustawia „Magazyn docelowy” w każdym wierszu tabeli Towary.,
-Sets 'Source Warehouse' in each row of the Items table.,Ustawia „Magazyn źródłowy” w każdym wierszu tabeli Towary.,
-POS Register,Rejestr POS,
-"Can not filter based on POS Profile, if grouped by POS Profile","Nie można filtrować na podstawie profilu POS, jeśli są pogrupowane według profilu POS",
-"Can not filter based on Customer, if grouped by Customer","Nie można filtrować na podstawie klienta, jeśli jest pogrupowany według klienta",
-"Can not filter based on Cashier, if grouped by Cashier","Nie można filtrować na podstawie Kasjera, jeśli jest pogrupowane według Kasjera",
-Payment Method,Metoda płatności,
-"Can not filter based on Payment Method, if grouped by Payment Method","Nie można filtrować na podstawie metody płatności, jeśli są pogrupowane według metody płatności",
-Supplier Quotation Comparison,Porównanie ofert dostawców,
-Price per Unit (Stock UOM),Cena za jednostkę (JM z magazynu),
-Group by Supplier,Grupuj według dostawcy,
-Group by Item,Grupuj według pozycji,
-Remember to set {field_label}. It is required by {regulation}.,"Pamiętaj, aby ustawić {field_label}. Jest to wymagane przez {przepis}.",
-Enrollment Date cannot be before the Start Date of the Academic Year {0},Data rejestracji nie może być wcześniejsza niż data rozpoczęcia roku akademickiego {0},
-Enrollment Date cannot be after the End Date of the Academic Term {0},Data rejestracji nie może być późniejsza niż data zakończenia okresu akademickiego {0},
-Enrollment Date cannot be before the Start Date of the Academic Term {0},Data rejestracji nie może być wcześniejsza niż data rozpoczęcia semestru akademickiego {0},
-Future Posting Not Allowed,Niedozwolone publikowanie w przyszłości,
-"To enable Capital Work in Progress Accounting, ","Aby włączyć księgowość produkcji w toku,",
-you must select Capital Work in Progress Account in accounts table,w tabeli kont należy wybrać Rachunek kapitałowy w toku,
-You can also set default CWIP account in Company {},Możesz także ustawić domyślne konto CWIP w firmie {},
-The Request for Quotation can be accessed by clicking on the following button,"Dostęp do zapytania ofertowego można uzyskać, klikając poniższy przycisk",
-Regards,pozdrowienia,
-Please click on the following button to set your new password,"Kliknij poniższy przycisk, aby ustawić nowe hasło",
-Update Password,Aktualizować hasło,
-Row #{}: Selling rate for item {} is lower than its {}. Selling {} should be atleast {},Wiersz nr {}: współczynnik sprzedaży dla przedmiotu {} jest niższy niż jego {}. Sprzedawanie {} powinno wynosić co najmniej {},
-You can alternatively disable selling price validation in {} to bypass this validation.,"Alternatywnie możesz wyłączyć weryfikację ceny sprzedaży w {}, aby ominąć tę weryfikację.",
-Invalid Selling Price,Nieprawidłowa cena sprzedaży,
-Address needs to be linked to a Company. Please add a row for Company in the Links table.,Adres musi być powiązany z firmą. Dodaj wiersz Firma w tabeli Łącza.,
-Company Not Linked,Firma niepowiązana,
-Import Chart of Accounts from CSV / Excel files,Importuj plan kont z plików CSV / Excel,
-Completed Qty cannot be greater than 'Qty to Manufacture',Ukończona ilość nie może być większa niż „Ilość do wyprodukowania”,
-"Row {0}: For Supplier {1}, Email Address is Required to send an email",Wiersz {0}: W przypadku dostawcy {1} do wysłania wiadomości e-mail wymagany jest adres e-mail,
-"If enabled, the system will post accounting entries for inventory automatically","Jeśli jest włączona, system automatycznie zaksięguje zapisy księgowe dotyczące zapasów",
-Accounts Frozen Till Date,Konta zamrożone do daty,
-Accounting entries are frozen up to this date. Nobody can create or modify entries except users with the role specified below,Do tej daty zapisy księgowe są zamrożone. Nikt nie może tworzyć ani modyfikować wpisów z wyjątkiem użytkowników z rolą określoną poniżej,
-Role Allowed to Set Frozen Accounts and Edit Frozen Entries,Rola dozwolona do ustawiania zamrożonych kont i edycji zamrożonych wpisów,
-Address used to determine Tax Category in transactions,Adres używany do określenia kategorii podatku w transakcjach,
-"The percentage you are allowed to bill more against the amount ordered. For example, if the order value is $100 for an item and tolerance is set as 10%, then you are allowed to bill up to $110 ","Procent, w jakim możesz zwiększyć rachunek od zamówionej kwoty. Na przykład, jeśli wartość zamówienia wynosi 100 USD za towar, a tolerancja jest ustawiona na 10%, możesz wystawić rachunek do 110 USD",
-This role is allowed to submit transactions that exceed credit limits,Ta rola umożliwia zgłaszanie transakcji przekraczających limity kredytowe,
-"If ""Months"" is selected, a fixed amount will be booked as deferred revenue or expense for each month irrespective of the number of days in a month. It will be prorated if deferred revenue or expense is not booked for an entire month","Jeśli zostanie wybrana opcja „Miesiące”, stała kwota zostanie zaksięgowana jako odroczone przychody lub wydatki dla każdego miesiąca, niezależnie od liczby dni w miesiącu. Zostanie naliczona proporcjonalnie, jeśli odroczone przychody lub wydatki nie zostaną zaksięgowane na cały miesiąc",
-"If this is unchecked, direct GL entries will be created to book deferred revenue or expense","Jeśli ta opcja nie jest zaznaczona, zostaną utworzone bezpośrednie wpisy GL w celu zaksięgowania odroczonych przychodów lub kosztów",
-Show Inclusive Tax in Print,Pokaż podatek wliczony w cenę w druku,
-Only select this if you have set up the Cash Flow Mapper documents,"Wybierz tę opcję tylko wtedy, gdy skonfigurowałeś dokumenty Cash Flow Mapper",
-Payment Channel,Kanał płatności,
-Is Purchase Order Required for Purchase Invoice & Receipt Creation?,Czy do wystawienia faktury i paragonu zakupu wymagane jest zamówienie zakupu?,
-Is Purchase Receipt Required for Purchase Invoice Creation?,Czy do utworzenia faktury zakupu jest wymagany dowód zakupu?,
-Maintain Same Rate Throughout the Purchase Cycle,Utrzymuj tę samą stawkę w całym cyklu zakupu,
-Allow Item To Be Added Multiple Times in a Transaction,Zezwalaj na wielokrotne dodawanie przedmiotu w transakcji,
-Suppliers,Dostawcy,
-Send Emails to Suppliers,Wyślij e-maile do dostawców,
-Select a Supplier,Wybierz dostawcę,
-Cannot mark attendance for future dates.,Nie można oznaczyć obecności na przyszłe daty.,
-Do you want to update attendance? <br> Present: {0} <br> Absent: {1},Czy chcesz zaktualizować frekwencję?<br> Obecnie: {0}<br> Nieobecny: {1},
-Mpesa Settings,Ustawienia Mpesa,
-Initiator Name,Nazwa inicjatora,
-Till Number,Do numeru,
-Sandbox,Piaskownica,
- Online PassKey,Online PassKey,
-Security Credential,Poświadczenie bezpieczeństwa,
-Get Account Balance,Sprawdź saldo konta,
-Please set the initiator name and the security credential,Ustaw nazwę inicjatora i poświadczenia bezpieczeństwa,
-Inpatient Medication Entry,Wpis leków szpitalnych,
-HLC-IME-.YYYY.-,HLC-IME-.YYYY.-,
-Item Code (Drug),Kod pozycji (lek),
-Medication Orders,Zamówienia na lekarstwa,
-Get Pending Medication Orders,Uzyskaj oczekujące zamówienia na leki,
-Inpatient Medication Orders,Zamówienia na leki szpitalne,
-Medication Warehouse,Magazyn leków,
-Warehouse from where medication stock should be consumed,"Magazyn, z którego należy skonsumować zapasy leków",
-Fetching Pending Medication Orders,Pobieranie oczekujących zamówień na leki,
-Inpatient Medication Entry Detail,Szczegóły dotyczące przyjmowania leków szpitalnych,
-Medication Details,Szczegóły leków,
-Drug Code,Kod leku,
-Drug Name,Nazwa leku,
-Against Inpatient Medication Order,Nakaz przeciwdziałania lekom szpitalnym,
-Against Inpatient Medication Order Entry,Wpis zamówienia przeciwko lekarstwom szpitalnym,
-Inpatient Medication Order,Zamówienie na leki szpitalne,
-HLC-IMO-.YYYY.-,HLC-IMO-.YYYY.-,
-Total Orders,Całkowita liczba zamówień,
-Completed Orders,Zrealizowane zamówienia,
-Add Medication Orders,Dodaj zamówienia na leki,
-Adding Order Entries,Dodawanie wpisów zamówienia,
-{0} medication orders completed,Zrealizowano {0} zamówień na leki,
-{0} medication order completed,Zrealizowano {0} zamówienie na lek,
-Inpatient Medication Order Entry,Wpis zamówienia leków szpitalnych,
-Is Order Completed,Zamówienie zostało zrealizowane,
-Employee Records to Be Created By,Dokumentacja pracowników do utworzenia przez,
-Employee records are created using the selected field,Rekordy pracowników są tworzone przy użyciu wybranego pola,
-Don't send employee birthday reminders,Nie wysyłaj pracownikom przypomnień o urodzinach,
-Restrict Backdated Leave Applications,Ogranicz aplikacje urlopowe z datą wsteczną,
-Sequence ID,Identyfikator sekwencji,
-Sequence Id,Id. Sekwencji,
-Allow multiple material consumptions against a Work Order,Zezwalaj na wielokrotne zużycie materiałów w ramach zlecenia pracy,
-Plan time logs outside Workstation working hours,Planuj dzienniki czasu poza godzinami pracy stacji roboczej,
-Plan operations X days in advance,Planuj operacje z X-dniowym wyprzedzeniem,
-Time Between Operations (Mins),Czas między operacjami (min),
-Default: 10 mins,Domyślnie: 10 min,
-Overproduction for Sales and Work Order,Nadprodukcja dla sprzedaży i zlecenia pracy,
-"Update BOM cost automatically via scheduler, based on the latest Valuation Rate/Price List Rate/Last Purchase Rate of raw materials","Aktualizuj koszt BOM automatycznie za pomocą harmonogramu, na podstawie ostatniego kursu wyceny / kursu cennika / ostatniego kursu zakupu surowców",
-Purchase Order already created for all Sales Order items,Zamówienie zakupu zostało już utworzone dla wszystkich pozycji zamówienia sprzedaży,
-Select Items,Wybierz elementy,
-Against Default Supplier,Wobec domyślnego dostawcy,
-Auto close Opportunity after the no. of days mentioned above,Automatyczne zamknięcie Okazja po nr. dni wymienionych powyżej,
-Is Sales Order Required for Sales Invoice & Delivery Note Creation?,Czy do tworzenia faktur sprzedaży i dokumentów dostawy wymagane jest zamówienie sprzedaży?,
-Is Delivery Note Required for Sales Invoice Creation?,Czy do utworzenia faktury sprzedaży jest wymagany dowód dostawy?,
-How often should Project and Company be updated based on Sales Transactions?,Jak często należy aktualizować projekt i firmę na podstawie transakcji sprzedaży?,
-Allow User to Edit Price List Rate in Transactions,Pozwól użytkownikowi edytować stawkę cennika w transakcjach,
-Allow Item to Be Added Multiple Times in a Transaction,Zezwalaj na wielokrotne dodawanie przedmiotu w transakcji,
-Allow Multiple Sales Orders Against a Customer's Purchase Order,Zezwalaj na wiele zamówień sprzedaży w ramach zamówienia klienta,
-Validate Selling Price for Item Against Purchase Rate or Valuation Rate,Sprawdź cenę sprzedaży przedmiotu w stosunku do kursu zakupu lub kursu wyceny,
-Hide Customer's Tax ID from Sales Transactions,Ukryj identyfikator podatkowy klienta w transakcjach sprzedaży,
-"The 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.","Procent, jaki możesz otrzymać lub dostarczyć więcej w stosunku do zamówionej ilości. Na przykład, jeśli zamówiłeś 100 jednostek, a Twój dodatek wynosi 10%, możesz otrzymać 110 jednostek.",
-Action If Quality Inspection Is Not Submitted,"Działanie, jeśli kontrola jakości nie zostanie przesłana",
-Auto Insert Price List Rate If Missing,"Automatycznie wstaw stawkę cennika, jeśli brakuje",
-Automatically Set Serial Nos Based on FIFO,Automatycznie ustaw numery seryjne w oparciu o FIFO,
-Set Qty in Transactions Based on Serial No Input,Ustaw ilość w transakcjach na podstawie numeru seryjnego,
-Raise Material Request When Stock Reaches Re-order Level,"Podnieś żądanie materiałowe, gdy zapasy osiągną poziom ponownego zamówienia",
-Notify by Email on Creation of Automatic Material Request,Powiadamiaj e-mailem o utworzeniu automatycznego wniosku o materiał,
-Allow Material Transfer from Delivery Note to Sales Invoice,Zezwól na przeniesienie materiału z potwierdzenia dostawy do faktury sprzedaży,
-Allow Material Transfer from Purchase Receipt to Purchase Invoice,Zezwól na przeniesienie materiału z paragonu zakupu do faktury zakupu,
-Freeze Stocks Older Than (Days),Zatrzymaj zapasy starsze niż (dni),
-Role Allowed to Edit Frozen Stock,Rola uprawniona do edycji zamrożonych zapasów,
-The unallocated amount of Payment Entry {0} is greater than the Bank Transaction's unallocated amount,Nieprzydzielona kwota wpisu płatności {0} jest większa niż nieprzydzielona kwota transakcji bankowej,
-Payment Received,Otrzymano zapłatę,
-Attendance cannot be marked outside of Academic Year {0},Nie można oznaczyć obecności poza rokiem akademickim {0},
-Student is already enrolled via Course Enrollment {0},Student jest już zapisany za pośrednictwem rejestracji na kurs {0},
-Attendance cannot be marked for future dates.,Nie można zaznaczyć obecności na przyszłe daty.,
-Please add programs to enable admission application.,"Dodaj programy, aby włączyć aplikację o przyjęcie.",
-The following employees are currently still reporting to {0}:,Następujący pracownicy nadal podlegają obecnie {0}:,
-Please make sure the employees above report to another Active employee.,"Upewnij się, że powyżsi pracownicy zgłaszają się do innego aktywnego pracownika.",
-Cannot Relieve Employee,Nie można zwolnić pracownika,
-Please enter {0},Wprowadź {0},
-Please select another payment method. Mpesa does not support transactions in currency '{0}',Wybierz inną metodę płatności. MPesa nie obsługuje transakcji w walucie „{0}”,
-Transaction Error,Błąd transakcji,
-Mpesa Express Transaction Error,Błąd transakcji Mpesa Express,
-"Issue detected with Mpesa configuration, check the error logs for more details","Wykryto problem z konfiguracją Mpesa, sprawdź dzienniki błędów, aby uzyskać więcej informacji",
-Mpesa Express Error,Błąd Mpesa Express,
-Account Balance Processing Error,Błąd przetwarzania salda konta,
-Please check your configuration and try again,Sprawdź konfigurację i spróbuj ponownie,
-Mpesa Account Balance Processing Error,Błąd przetwarzania salda konta Mpesa,
-Balance Details,Szczegóły salda,
-Current Balance,Aktualne saldo,
-Available Balance,Dostępne saldo,
-Reserved Balance,Zarezerwowane saldo,
-Uncleared Balance,Nierówna równowaga,
-Payment related to {0} is not completed,Płatność związana z {0} nie została zakończona,
-Row #{}: Item Code: {} is not available under warehouse {}.,Wiersz nr {}: kod towaru: {} nie jest dostępny w magazynie {}.,
-Row #{}: Stock quantity not enough for Item Code: {} under warehouse {}. Available quantity {}.,Wiersz nr {}: Niewystarczająca ilość towaru dla kodu towaru: {} w magazynie {}. Dostępna Ilość {}.,
-Row #{}: Please select a serial no and batch against item: {} or remove it to complete transaction.,"Wiersz nr {}: Wybierz numer seryjny i partię dla towaru: {} lub usuń je, aby zakończyć transakcję.",
-Row #{}: No serial number selected against item: {}. Please select one or remove it to complete transaction.,"Wiersz nr {}: nie wybrano numeru seryjnego dla pozycji: {}. Wybierz jeden lub usuń go, aby zakończyć transakcję.",
-Row #{}: No batch selected against item: {}. Please select a batch or remove it to complete transaction.,"Wiersz nr {}: nie wybrano partii dla elementu: {}. Wybierz pakiet lub usuń go, aby zakończyć transakcję.",
-Payment amount cannot be less than or equal to 0,Kwota płatności nie może być mniejsza lub równa 0,
-Please enter the phone number first,Najpierw wprowadź numer telefonu,
-Row #{}: {} {} does not exist.,Wiersz nr {}: {} {} nie istnieje.,
-Row #{0}: {1} is required to create the Opening {2} Invoices,Wiersz nr {0}: {1} jest wymagany do utworzenia faktur otwarcia {2},
-You had {} errors while creating opening invoices. Check {} for more details,"Podczas otwierania faktur wystąpiło {} błędów. Sprawdź {}, aby uzyskać więcej informacji",
-Error Occured,Wystąpił błąd,
-Opening Invoice Creation In Progress,Otwieranie faktury w toku,
-Creating {} out of {} {},Tworzenie {} z {} {},
-(Serial No: {0}) cannot be consumed as it's reserverd to fullfill Sales Order {1}.,"(Nr seryjny: {0}) nie może zostać wykorzystany, ponieważ jest ponownie wysyłany w celu wypełnienia zamówienia sprzedaży {1}.",
-Item {0} {1},Przedmiot {0} {1},
-Last Stock Transaction for item {0} under warehouse {1} was on {2}.,Ostatnia transakcja magazynowa dotycząca towaru {0} w magazynie {1} miała miejsce w dniu {2}.,
-Stock Transactions for Item {0} under warehouse {1} cannot be posted before this time.,Transakcje magazynowe dla pozycji {0} w magazynie {1} nie mogą być księgowane przed tą godziną.,
-Posting future stock transactions are not allowed due to Immutable Ledger,Księgowanie przyszłych transakcji magazynowych nie jest dozwolone ze względu na niezmienną księgę,
-A BOM with name {0} already exists for item {1}.,Zestawienie komponentów o nazwie {0} już istnieje dla towaru {1}.,
-{0}{1} Did you rename the item? Please contact Administrator / Tech support,{0} {1} Czy zmieniłeś nazwę elementu? Skontaktuj się z administratorem / pomocą techniczną,
-At row #{0}: the sequence id {1} cannot be less than previous row sequence id {2},W wierszu {0}: identyfikator sekwencji {1} nie może być mniejszy niż identyfikator sekwencji poprzedniego wiersza {2},
-The {0} ({1}) must be equal to {2} ({3}),{0} ({1}) musi być równe {2} ({3}),
-"{0}, complete the operation {1} before the operation {2}.","{0}, zakończ operację {1} przed operacją {2}.",
-Cannot ensure delivery by Serial No as Item {0} is added with and without Ensure Delivery by Serial No.,"Nie można zapewnić dostawy według numeru seryjnego, ponieważ pozycja {0} jest dodawana zi bez opcji Zapewnij dostawę według numeru seryjnego.",
-Item {0} has no Serial No. Only serilialized items can have delivery based on Serial No,Przedmiot {0} nie ma numeru seryjnego. Tylko przesyłki seryjne mogą być dostarczane na podstawie numeru seryjnego,
-No active BOM found for item {0}. Delivery by Serial No cannot be ensured,Nie znaleziono aktywnego zestawienia komponentów dla pozycji {0}. Nie można zagwarantować dostawy według numeru seryjnego,
-No pending medication orders found for selected criteria,Nie znaleziono oczekujących zamówień na leki dla wybranych kryteriów,
-From Date cannot be after the current date.,Data początkowa nie może być późniejsza niż data bieżąca.,
-To Date cannot be after the current date.,Data końcowa nie może być późniejsza niż data bieżąca.,
-From Time cannot be after the current time.,Od godziny nie może być późniejsza niż aktualna godzina.,
-To Time cannot be after the current time.,To Time nie może być późniejsze niż aktualna godzina.,
-Stock Entry {0} created and ,Utworzono wpis giełdowy {0} i,
-Inpatient Medication Orders updated successfully,Zamówienia na leki szpitalne zostały pomyślnie zaktualizowane,
-Row {0}: Cannot create Inpatient Medication Entry against cancelled Inpatient Medication Order {1},Wiersz {0}: Cannot create the Inpatient Medication Entry for an incpatient medication Order {1},
-Row {0}: This Medication Order is already marked as completed,Wiersz {0}: to zamówienie na lek jest już oznaczone jako zrealizowane,
-Quantity not available for {0} in warehouse {1},Ilość niedostępna dla {0} w magazynie {1},
-Please enable Allow Negative Stock in Stock Settings or create Stock Entry to proceed.,"Włącz opcję Zezwalaj na ujemne zapasy w ustawieniach zapasów lub utwórz wpis zapasów, aby kontynuować.",
-No Inpatient Record found against patient {0},Nie znaleziono dokumentacji szpitalnej dotyczącej pacjenta {0},
-An Inpatient Medication Order {0} against Patient Encounter {1} already exists.,Istnieje już nakaz leczenia szpitalnego {0} przeciwko spotkaniu z pacjentami {1}.,
-Allow In Returns,Zezwalaj na zwroty,
-Hide Unavailable Items,Ukryj niedostępne elementy,
-Apply Discount on Discounted Rate,Zastosuj zniżkę na obniżoną stawkę,
-Therapy Plan Template,Szablon planu terapii,
-Fetching Template Details,Pobieranie szczegółów szablonu,
-Linked Item Details,Szczegóły połączonego elementu,
-Therapy Types,Rodzaje terapii,
-Therapy Plan Template Detail,Szczegóły szablonu planu terapii,
-Non Conformance,Niezgodność,
-Process Owner,Właściciel procesu,
-Corrective Action,Działania naprawcze,
-Preventive Action,Akcja prewencyjna,
-Problem,Problem,
-Responsible,Odpowiedzialny,
-Completion By,Zakończenie do,
-Process Owner Full Name,Imię i nazwisko właściciela procesu,
-Right Index,Prawy indeks,
-Left Index,Lewy indeks,
-Sub Procedure,Procedura podrzędna,
-Passed,Zdał,
-Print Receipt,Wydrukuj pokwitowanie,
-Edit Receipt,Edytuj rachunek,
-Focus on search input,Skoncentruj się na wyszukiwaniu,
-Focus on Item Group filter,Skoncentruj się na filtrze grupy przedmiotów,
-Checkout Order / Submit Order / New Order,Zamówienie do kasy / Prześlij zamówienie / Nowe zamówienie,
-Add Order Discount,Dodaj rabat na zamówienie,
-Item Code: {0} is not available under warehouse {1}.,Kod towaru: {0} nie jest dostępny w magazynie {1}.,
-Serial numbers unavailable for Item {0} under warehouse {1}. Please try changing warehouse.,Numery seryjne są niedostępne dla towaru {0} w magazynie {1}. Spróbuj zmienić magazyn.,
-Fetched only {0} available serial numbers.,Pobrano tylko {0} dostępnych numerów seryjnych.,
-Switch Between Payment Modes,Przełącz między trybami płatności,
-Enter {0} amount.,Wprowadź kwotę {0}.,
-You don't have enough points to redeem.,"Nie masz wystarczającej liczby punktów, aby je wymienić.",
-You can redeem upto {0}.,Możesz wykorzystać maksymalnie {0}.,
-Enter amount to be redeemed.,Wprowadź kwotę do wykupu.,
-You cannot redeem more than {0}.,Nie możesz wykorzystać więcej niż {0}.,
-Open Form View,Otwórz widok formularza,
-POS invoice {0} created succesfully,Faktura POS {0} została utworzona pomyślnie,
-Stock quantity not enough for Item Code: {0} under warehouse {1}. Available quantity {2}.,Za mało towaru dla kodu towaru: {0} w magazynie {1}. Dostępna ilość {2}.,
-Serial No: {0} has already been transacted into another POS Invoice.,Nr seryjny: {0} został już sprzedany na inną fakturę POS.,
-Balance Serial No,Nr seryjny wagi,
-Warehouse: {0} does not belong to {1},Magazyn: {0} nie należy do {1},
-Please select batches for batched item {0},Wybierz partie dla produktu wsadowego {0},
-Please select quantity on row {0},Wybierz ilość w wierszu {0},
-Please enter serial numbers for serialized item {0},Wprowadź numery seryjne dla towaru z numerem seryjnym {0},
-Batch {0} already selected.,Wiązka {0} już wybrana.,
-Please select a warehouse to get available quantities,"Wybierz magazyn, aby uzyskać dostępne ilości",
-"For transfer from source, selected quantity cannot be greater than available quantity",W przypadku transferu ze źródła wybrana ilość nie może być większa niż ilość dostępna,
-Cannot find Item with this Barcode,Nie można znaleźć przedmiotu z tym kodem kreskowym,
-{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2},{0} jest obowiązkowe. Być może rekord wymiany walut nie jest tworzony dla {1} do {2},
-{} has submitted assets linked to it. You need to cancel the assets to create purchase return.,"{} przesłał zasoby z nim powiązane. Musisz anulować zasoby, aby utworzyć zwrot zakupu.",
-Cannot cancel this document as it is linked with submitted asset {0}. Please cancel it to continue.,"Nie można anulować tego dokumentu, ponieważ jest on powiązany z przesłanym zasobem {0}. Anuluj, aby kontynuować.",
-Row #{}: Serial No. {} has already been transacted into another POS Invoice. Please select valid serial no.,Wiersz nr {}: Numer seryjny {} został już przetworzony na inną fakturę POS. Proszę wybrać prawidłowy numer seryjny.,
-Row #{}: Serial Nos. {} has already been transacted into another POS Invoice. Please select valid serial no.,Wiersz nr {}: numery seryjne {} zostały już przetworzone na inną fakturę POS. Proszę wybrać prawidłowy numer seryjny.,
-Item Unavailable,Pozycja niedostępna,
-Row #{}: Serial No {} cannot be returned since it was not transacted in original invoice {},"Wiersz nr {}: nr seryjny {} nie może zostać zwrócony, ponieważ nie był przedmiotem transakcji na oryginalnej fakturze {}",
-Please set default Cash or Bank account in Mode of Payment {},Ustaw domyślne konto gotówkowe lub bankowe w trybie płatności {},
-Please set default Cash or Bank account in Mode of Payments {},Ustaw domyślne konto gotówkowe lub bankowe w Trybie płatności {},
-Please ensure {} account is a Balance Sheet account. You can change the parent account to a Balance Sheet account or select a different account.,"Upewnij się, że konto {} jest kontem bilansowym. Możesz zmienić konto nadrzędne na konto bilansowe lub wybrać inne konto.",
-Please ensure {} account is a Payable account. Change the account type to Payable or select a different account.,"Upewnij się, że konto {} jest kontem płatnym. Zmień typ konta na Płatne lub wybierz inne konto.",
-Row {}: Expense Head changed to {} ,Wiersz {}: nagłówek wydatków zmieniony na {},
-because account {} is not linked to warehouse {} ,ponieważ konto {} nie jest połączone z magazynem {},
-or it is not the default inventory account,lub nie jest to domyślne konto magazynowe,
-Expense Head Changed,Zmiana głowy wydatków,
-because expense is booked against this account in Purchase Receipt {},ponieważ wydatek jest księgowany na tym koncie na dowodzie zakupu {},
-as no Purchase Receipt is created against Item {}. ,ponieważ dla przedmiotu {} nie jest tworzony dowód zakupu.,
-This is done to handle accounting for cases when Purchase Receipt is created after Purchase Invoice,"Ma to na celu obsługę księgowania przypadków, w których paragon zakupu jest tworzony po fakturze zakupu",
-Purchase Order Required for item {},Wymagane zamówienie zakupu dla produktu {},
-To submit the invoice without purchase order please set {} ,"Aby przesłać fakturę bez zamówienia, należy ustawić {}",
-as {} in {},jak w {},
-Mandatory Purchase Order,Obowiązkowe zamówienie zakupu,
-Purchase Receipt Required for item {},Potwierdzenie zakupu jest wymagane dla przedmiotu {},
-To submit the invoice without purchase receipt please set {} ,"Aby przesłać fakturę bez dowodu zakupu, ustaw {}",
-Mandatory Purchase Receipt,Obowiązkowy dowód zakupu,
-POS Profile {} does not belongs to company {},Profil POS {} nie należy do firmy {},
-User {} is disabled. Please select valid user/cashier,Użytkownik {} jest wyłączony. Wybierz prawidłowego użytkownika / kasjera,
-Row #{}: Original Invoice {} of return invoice {} is {}. ,Wiersz nr {}: Oryginalna faktura {} faktury zwrotnej {} to {}.,
-Original invoice should be consolidated before or along with the return invoice.,Oryginał faktury należy skonsolidować przed lub wraz z fakturą zwrotną.,
-You can add original invoice {} manually to proceed.,"Aby kontynuować, możesz ręcznie dodać oryginalną fakturę {}.",
-Please ensure {} account is a Balance Sheet account. ,"Upewnij się, że konto {} jest kontem bilansowym.",
-You can change the parent account to a Balance Sheet account or select a different account.,Możesz zmienić konto nadrzędne na konto bilansowe lub wybrać inne konto.,
-Please ensure {} account is a Receivable account. ,"Upewnij się, że konto {} jest kontem należnym.",
-Change the account type to Receivable or select a different account.,Zmień typ konta na Odbywalne lub wybierz inne konto.,
-{} can't be cancelled since the Loyalty Points earned has been redeemed. First cancel the {} No {},"Nie można anulować {}, ponieważ zebrane punkty lojalnościowe zostały wykorzystane. Najpierw anuluj {} Nie {}",
-already exists,już istnieje,
-POS Closing Entry {} against {} between selected period,Wejście zamknięcia POS {} względem {} między wybranym okresem,
-POS Invoice is {},Faktura POS to {},
-POS Profile doesn't matches {},Profil POS nie pasuje {},
-POS Invoice is not {},Faktura POS nie jest {},
-POS Invoice isn't created by user {},Faktura POS nie jest tworzona przez użytkownika {},
-Row #{}: {},Wiersz nr {}: {},
-Invalid POS Invoices,Nieprawidłowe faktury POS,
-Please add the account to root level Company - {},Dodaj konto do poziomu Firma - {},
-"While creating account for Child Company {0}, parent account {1} not found. Please create the parent account in corresponding COA",Podczas tworzenia konta dla firmy podrzędnej {0} nie znaleziono konta nadrzędnego {1}. Utwórz konto rodzica w odpowiednim certyfikacie autentyczności,
-Account Not Found,Konto nie znalezione,
-"While creating account for Child Company {0}, parent account {1} found as a ledger account.",Podczas tworzenia konta dla Firmy podrzędnej {0} konto nadrzędne {1} zostało uznane za konto księgowe.,
-Please convert the parent account in corresponding child company to a group account.,Zmień konto nadrzędne w odpowiedniej firmie podrzędnej na konto grupowe.,
-Invalid Parent Account,Nieprawidłowe konto nadrzędne,
-"Renaming it is only allowed via parent company {0}, to avoid mismatch.","Zmiana nazwy jest dozwolona tylko za pośrednictwem firmy macierzystej {0}, aby uniknąć niezgodności.",
-"If you {0} {1} quantities of the item {2}, the scheme {3} will be applied on the item.",W przypadku {0} {1} ilości towaru {2} schemat {3} zostanie zastosowany do towaru.,
-"If you {0} {1} worth item {2}, the scheme {3} will be applied on the item.","Jeśli {0} {1} cenisz przedmiot {2}, schemat {3} zostanie zastosowany do elementu.",
-"As the field {0} is enabled, the field {1} is mandatory.","Ponieważ pole {0} jest włączone, pole {1} jest obowiązkowe.",
-"As the field {0} is enabled, the value of the field {1} should be more than 1.","Ponieważ pole {0} jest włączone, wartość pola {1} powinna być większa niż 1.",
-Cannot deliver Serial No {0} of item {1} as it is reserved to fullfill Sales Order {2},"Nie można dostarczyć numeru seryjnego {0} elementu {1}, ponieważ jest on zarezerwowany do realizacji zamówienia sprzedaży {2}",
-"Sales Order {0} has reservation for the item {1}, you can only deliver reserved {1} against {0}.","Zamówienie sprzedaży {0} ma rezerwację na produkt {1}, możesz dostarczyć zarezerwowane tylko {1} w ramach {0}.",
-{0} Serial No {1} cannot be delivered,Nie można dostarczyć {0} numeru seryjnego {1},
-Row {0}: Subcontracted Item is mandatory for the raw material {1},Wiersz {0}: Pozycja podwykonawcza jest obowiązkowa dla surowca {1},
-"As there are sufficient raw materials, Material Request is not required for Warehouse {0}.","Ponieważ ilość surowców jest wystarczająca, żądanie materiałów nie jest wymagane dla magazynu {0}.",
-" If you still want to proceed, please enable {0}.","Jeśli nadal chcesz kontynuować, włącz {0}.",
-The item referenced by {0} - {1} is already invoiced,"Pozycja, do której odwołuje się {0} - {1}, została już zafakturowana",
-Therapy Session overlaps with {0},Sesja terapeutyczna pokrywa się z {0},
-Therapy Sessions Overlapping,Nakładanie się sesji terapeutycznych,
-Therapy Plans,Plany terapii,
-"Item Code, warehouse, quantity are required on row {0}","Kod pozycji, magazyn, ilość są wymagane w wierszu {0}",
-Get Items from Material Requests against this Supplier,Pobierz pozycje z żądań materiałowych od tego dostawcy,
-Enable European Access,Włącz dostęp w Europie,
-Creating Purchase Order ...,Tworzenie zamówienia zakupu ...,
-"Select a Supplier from the Default Suppliers of the items below. On selection, a Purchase Order will be made against items belonging to the selected Supplier only.","Wybierz dostawcę spośród domyślnych dostawców z poniższych pozycji. Po dokonaniu wyboru, Zamówienie zostanie złożone wyłącznie dla pozycji należących do wybranego Dostawcy.",
-Row #{}: You must select {} serial numbers for item {}.,Wiersz nr {}: należy wybrać {} numery seryjne dla towaru {}.,
+"""Customer Provided Item"" cannot be Purchase Item also","""Element dostarczony przez klienta"" nie może być również elementem nabycia",
+"""Customer Provided Item"" cannot have Valuation Rate","""Element dostarczony przez klienta"" nie może mieć wskaźnika wyceny",
+"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","""Jest Środkiem Trwałym"" nie może być odznaczone, jeśli istnieją pozycje z takim ustawieniem",
+'Based On' and 'Group By' can not be same,"Pola ""Bazuje na"" i ""Grupuj wg."" nie mogą być takie same",
+'Days Since Last Order' must be greater than or equal to zero,Pole 'Dni od ostatniego zamówienia' musi być większe bądź równe zero,
+'Entries' cannot be empty,Pole 'Wpisy' nie może być puste,
+'From Date' is required,Pole 'Od daty' jest wymagane,
+'From Date' must be after 'To Date',Pole 'Od daty' musi następować później niż 'Do daty',
+'Has Serial No' can not be 'Yes' for non-stock item,Numer seryjny nie jest dostępny dla pozycji niemagazynowych,
+'Opening',&quot;Otwarcie&quot;,
+'To Case No.' cannot be less than 'From Case No.','To Case No.' nie powinno być mniejsze niż 'From Case No.',
+'To Date' is required,'Do daty' jest wymaganym polem,
+'Total',&#39;Całkowity&#39;,
+'Update Stock' can not be checked because items are not delivered via {0},"'Aktualizuj Stan' nie może być zaznaczone, ponieważ elementy nie są dostarczane przez {0}",
+'Update Stock' cannot be checked for fixed asset sale,Opcja 'Aktualizuj Stan' nie może być zaznaczona dla sprzedaży środka trwałego,
+) for {0},) dla {0},
+1 exact match.,1 dokładny mecz.,
+90-Above,90-Ponad,
+A Customer Group exists with same name please change the Customer name or rename the Customer Group,Grupa Odbiorców posiada taką nazwę - wprowadź inną nazwę Odbiorcy lub zmień nazwę Grupy,
+A Default Service Level Agreement already exists.,Domyślna umowa dotycząca poziomu usług już istnieje.,
+A Lead requires either a person's name or an organization's name,Ołów wymaga nazwy osoby lub nazwy organizacji,
+A customer with the same name already exists,Klient o tej samej nazwie już istnieje,
+A question must have more than one options,Pytanie musi mieć więcej niż jedną opcję,
+A qustion must have at least one correct options,Qustion musi mieć co najmniej jedną poprawną opcję,
+A {0} exists between {1} and {2} (,{0} istnieje pomiędzy {1} a {2} (,
+A4,A4,
+API Endpoint,Punkt końcowy API,
+API Key,Klucz API,
+Abbr can not be blank or space,Skrót nie może być pusty lub być spacją,
+Abbreviation already used for another company,Skrót już używany przez inną firmę,
+Abbreviation cannot have more than 5 characters,Skrót nie może posiadać więcej niż 5 znaków,
+Abbreviation is mandatory,Skrót jest obowiązkowy,
+About the Company,O firmie,
+About your company,O Twojej firmie,
+Above,Powyżej,
+Absent,Nieobecny,
+Academic Term,semestr,
+Academic Term: ,Okres akademicki:,
+Academic Year,Rok akademicki,
+Academic Year: ,Rok akademicki:,
+Accepted + Rejected Qty must be equal to Received quantity for Item {0},Ilość Przyjętych + Odrzuconych musi odpowiadać ilości Odebranych (Element {0}),
+Access Token,Dostęp za pomocą Tokenu,
+Accessable Value,Dostępna wartość,
+Account,Konto,
+Account Number,Numer konta,
+Account Number {0} already used in account {1},Numer konta {0} jest już używany na koncie {1},
+Account Pay Only,Tylko płatne konto,
+Account Type,typ konta,
+Account Type for {0} must be {1},Typ konta dla {0} musi być {1},
+"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Konto jest na minusie, nie możesz ustawić wymagań jako debet.",
+"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Konto jest na minusie, nie możesz ustawić wymagań jako kredyt.",
+Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Numer konta dla konta {0} jest niedostępny. <br> Skonfiguruj poprawnie swój plan kont.,
+Account with child nodes cannot be converted to ledger,Konto grupujące inne konta nie może być konwertowane,
+Account with child nodes cannot be set as ledger,Konto z węzłów podrzędnych nie może być ustawiony jako księgi,
+Account with existing transaction can not be converted to group.,Konto z istniejącymi zapisami nie może być konwertowane na Grupę (konto dzielone).,
+Account with existing transaction can not be deleted,Konto z istniejącymi zapisami nie może być usunięte,
+Account with existing transaction cannot be converted to ledger,Konto z istniejącymi zapisami nie może być konwertowane,
+Account {0} does not belong to company: {1},Konto {0} nie należy do firmy: {1},
+Account {0} does not belongs to company {1},Konto {0} nie należy do firmy {1},
+Account {0} does not exist,Konto {0} nie istnieje,
+Account {0} does not exists,Konto {0} nie istnieje,
+Account {0} does not match with Company {1} in Mode of Account: {2},Konto {0} nie jest zgodne z firmą {1} w trybie konta: {2},
+Account {0} has been entered multiple times,Konto {0} zostało wprowadzone wielokrotnie,
+Account {0} is added in the child company {1},Konto {0} zostało dodane w firmie podrzędnej {1},
+Account {0} is frozen,Konto {0} jest zamrożone,
+Account {0} is invalid. Account Currency must be {1},Konto {0} jest nieprawidłowe. Waluta konta musi być {1},
+Account {0}: Parent account {1} can not be a ledger,Konto {0}: Nadrzędne konto {1} nie może być zwykłym,
+Account {0}: Parent account {1} does not belong to company: {2},Konto {0}: konto nadrzędne {1} nie należy do firmy: {2},
+Account {0}: Parent account {1} does not exist,Konto {0}: Konto nadrzędne {1} nie istnieje,
+Account {0}: You can not assign itself as parent account,Konto {0}: Nie można przypisać siebie jako konta nadrzędnego,
+Account: {0} can only be updated via Stock Transactions,Konto: {0} może być aktualizowana tylko przez operacje magazynowe,
+Account: {0} with currency: {1} can not be selected,Konto: {0} z waluty: nie można wybrać {1},
+Accountant,Księgowy,
+Accounting,Księgowość,
+Accounting Entry for Asset,Zapis Księgowy dla aktywów,
+Accounting Entry for Stock,Zapis księgowy dla zapasów,
+Accounting Entry for {0}: {1} can only be made in currency: {2},Wprowadzenia danych księgowych dla {0}: {1} może być dokonywane wyłącznie w walucie: {2},
+Accounting Ledger,Księgi rachunkowe,
+Accounting journal entries.,Dziennik zapisów księgowych.,
+Accounts,Księgowość,
+Accounts Manager,Specjalista ds. Sprzedaży,
+Accounts Payable,Zobowiązania,
+Accounts Payable Summary,Zobowiązania Podsumowanie,
+Accounts Receivable,Należności,
+Accounts Receivable Summary,Należności Podsumowanie,
+Accounts User,Konta Użytkownika,
+Accounts table cannot be blank.,Tabela kont nie może być pusta,
+Accrual Journal Entry for salaries from {0} to {1},Zapis wstępny w dzienniku dla zarobków od {0} do {1},
+Accumulated Depreciation,Umorzenia (skumulowana amortyzacja),
+Accumulated Depreciation Amount,Kwota Skumulowanej amortyzacji,
+Accumulated Depreciation as on,Skumulowana amortyzacja jak na,
+Accumulated Monthly,skumulowane miesięcznie,
+Accumulated Values,Skumulowane wartości,
+Accumulated Values in Group Company,Skumulowane wartości w Spółce Grupy,
+Achieved ({}),Osiągnięto ({}),
+Action,Działanie,
+Action Initialised,Działanie zainicjowane,
+Actions,działania,
+Active,Aktywny,
+Activity Cost exists for Employee {0} against Activity Type - {1},Istnieje aktywny Koszt Pracodawcy {0} przed Type Aktywny - {1},
+Activity Cost per Employee,Koszt aktywność na pracownika,
+Activity Type,Rodzaj aktywności,
+Actual Cost,Aktualna cena,
+Actual Delivery Date,Rzeczywista data dostawy,
+Actual Qty,Rzeczywista ilość,
+Actual Qty is mandatory,Rzeczywista ilość jest obowiązkowa,
+Actual Qty {0} / Waiting Qty {1},Rzeczywista ilość {0} / liczba oczekujących {1},
+Actual Qty: Quantity available in the warehouse.,Rzeczywista ilość: ilość dostępna w magazynie.,
+Actual qty in stock,Rzeczywista ilość w magazynie,
+Actual type tax cannot be included in Item rate in row {0},Rzeczywista Podatek typu nie mogą być wliczone w cenę towaru w wierszu {0},
+Add,Dodaj,
+Add / Edit Prices,Dodaj / edytuj ceny,
+Add Comment,Dodaj komentarz,
+Add Customers,Dodaj klientów,
+Add Employees,Dodaj pracowników,
+Add Item,Dodaj pozycję,
+Add Items,Dodaj pozycje,
+Add Leads,Dodaj namiary,
+Add Multiple Tasks,Dodaj wiele zadań,
+Add Row,Dodaj wiersz,
+Add Sales Partners,Dodaj partnerów handlowych,
+Add Serial No,Dodaj nr seryjny,
+Add Students,Dodaj uczniów,
+Add Suppliers,Dodaj dostawców,
+Add Time Slots,Dodaj gniazda czasowe,
+Add Timesheets,Dodaj ewidencja czasu pracy,
+Add Timeslots,Dodaj czasopisma,
+Add Users to Marketplace,Dodaj użytkowników do rynku,
+Add a new address,Dodaj nowy adres,
+Add cards or custom sections on homepage,Dodaj karty lub niestandardowe sekcje na stronie głównej,
+Add more items or open full form,Dodać więcej rzeczy lub otworzyć pełną formę,
+Add notes,Dodaj notatki,
+Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,Dodać resztę organizacji jako użytkowników. Można również dodać zaprosić klientów do portalu dodając je z Kontaktów,
+Add to Details,Dodaj do szczegółów,
+Add/Remove Recipients,Dodaj / usuń odbiorców,
+Added,Dodano,
+Added to details,Dodano do szczegółów,
+Added {0} users,Dodano {0} użytkowników,
+Additional Salary Component Exists.,Istnieje dodatkowy składnik wynagrodzenia.,
+Address,Adres,
+Address Line 2,Drugi wiersz adresu,
+Address Name,Adres,
+Address Title,Tytuł adresu,
+Address Type,Typ adresu,
+Administrative Expenses,Wydatki na podstawową działalność,
+Administrative Officer,Urzędnik administracyjny,
+Administrator,Administrator,
+Admission,Wstęp,
+Admission and Enrollment,Wstęp i rejestracja,
+Admissions for {0},Rekrutacja dla {0},
+Admit,Przyznać,
+Admitted,Przyznał,
+Advance Amount,Kwota Zaliczki,
+Advance Payments,Zaliczki,
+Advance account currency should be same as company currency {0},"Waluta konta Advance powinna być taka sama, jak waluta firmy {0}",
+Advance amount cannot be greater than {0} {1},Ilość wyprzedzeniem nie może być większa niż {0} {1},
+Advertising,Reklamowanie,
+Aerospace,Lotnictwo,
+Against,Wyklucza,
+Against Account,Konto korespondujące,
+Against Journal Entry {0} does not have any unmatched {1} entry,Przeciwko Urzędowym Wejście {0} nie ma niezrównaną pozycję {1},
+Against Journal Entry {0} is already adjusted against some other voucher,Zapis {0} jest już powiązany z innym dowodem księgowym,
+Against Supplier Invoice {0} dated {1},Przeciwko Dostawcę faktury {0} {1} dnia,
+Against Voucher,Dowód księgowy,
+Against Voucher Type,Rodzaj dowodu,
+Age,Wiek,
+Age (Days),Wiek (dni),
+Ageing Based On,Starzenie na podstawie,
+Ageing Range 1,Starzenie Zakres 1,
+Ageing Range 2,Starzenie Zakres 2,
+Ageing Range 3,Starzenie Zakres 3,
+Agriculture,Rolnictwo,
+Agriculture (beta),Rolnictwo (beta),
+Airline,Linia lotnicza,
+All Accounts,Wszystkie konta,
+All Addresses.,Wszystkie adresy,
+All Assessment Groups,Wszystkie grupy oceny,
+All BOMs,Wszystkie LM,
+All Contacts.,Wszystkie kontakty.,
+All Customer Groups,Wszystkie grupy klientów,
+All Day,Cały Dzień,
+All Departments,Wszystkie departamenty,
+All Healthcare Service Units,Wszystkie jednostki służby zdrowia,
+All Item Groups,Wszystkie grupy produktów,
+All Jobs,Wszystkie Oferty pracy,
+All Products,Wszystkie produkty,
+All Products or Services.,Wszystkie produkty i usługi.,
+All Student Admissions,Wszystkie Przyjęć studenckie,
+All Supplier Groups,Wszystkie grupy dostawców,
+All Supplier scorecards.,Wszystkie karty oceny dostawcy.,
+All Territories,Wszystkie obszary,
+All Warehouses,Wszystkie magazyny,
+All communications including and above this shall be moved into the new Issue,"Wszystkie komunikaty, w tym i powyżej tego, zostaną przeniesione do nowego wydania",
+All items have already been transferred for this Work Order.,Wszystkie przedmioty zostały już przekazane dla tego zlecenia pracy.,
+All other ITC,Wszystkie inne ITC,
+All the mandatory Task for employee creation hasn't been done yet.,Wszystkie obowiązkowe zadanie tworzenia pracowników nie zostało jeszcze wykonane.,
+Allocate Payment Amount,Przeznaczyć Kwota płatności,
+Allocated Amount,Przyznana kwota,
+Allocated Leaves,Przydzielone Nieobecności,
+Allocating leaves...,Przydzielanie Nieobecności...,
+Already record exists for the item {0},Już istnieje rekord dla elementu {0},
+"Already set default in pos profile {0} for user {1}, kindly disabled default","Już ustawiono domyślne w profilu pozycji {0} dla użytkownika {1}, domyślnie wyłączone",
+Alternate Item,Alternatywna pozycja,
+Alternative item must not be same as item code,"Element alternatywny nie może być taki sam, jak kod produktu",
+Amended From,Zmodyfikowany od,
+Amount,Wartość,
+Amount After Depreciation,Kwota po amortyzacji,
+Amount of Integrated Tax,Kwota Zintegrowanego Podatku,
+Amount of TDS Deducted,Kwota potrąconej TDS,
+Amount should not be less than zero.,Kwota nie powinna być mniejsza niż zero.,
+Amount to Bill,Kwota rachunku,
+Amount {0} {1} against {2} {3},Kwota {0} {1} przeciwko {2} {3},
+Amount {0} {1} deducted against {2},Kwota {0} {1} odliczone przed {2},
+Amount {0} {1} transferred from {2} to {3},"Kwota {0} {1} przeniesione z {2} {3}, aby",
+Amount {0} {1} {2} {3},Kwota {0} {1} {2} {3},
+Amt,Amt,
+"An Item Group exists with same name, please change the item name or rename the item group",Istnieje element Grupy o takiej nazwie. Zmień nazwę elementu lub tamtej Grupy.,
+An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Semestr z tym &quot;Roku Akademickiego&quot; {0} i &#39;Nazwa Termin&#39; {1} już istnieje. Proszę zmodyfikować te dane i spróbuj jeszcze raz.,
+An error occurred during the update process,Wystąpił błąd podczas procesu aktualizacji,
+"An item exists with same name ({0}), please change the item group name or rename the item",Istnieje element  o takiej nazwie. Zmień nazwę Grupy lub tego elementu.,
+Analyst,Analityk,
+Analytics,Analityk,
+Annual Billing: {0},Roczne rozliczeniowy: {0},
+Annual Salary,Roczne wynagrodzenie,
+Anonymous,Anonimowy,
+Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},Inny rekord budżetu &quot;{0}&quot; już istnieje w stosunku do {1} &quot;{2}&quot; i konta &quot;{3}&quot; w roku finansowym {4},
+Another Period Closing Entry {0} has been made after {1},Kolejny okres Zamknięcie Wejście {0} została wykonana po {1},
+Another Sales Person {0} exists with the same Employee id,Inna osoba Sprzedaż {0} istnieje w tym samym identyfikator pracownika,
+Antibiotic,Antybiotyk,
+Apparel & Accessories,Odzież i akcesoria,
+Applicable For,Stosowne dla,
+"Applicable if the company is SpA, SApA or SRL","Stosuje się, jeśli spółką jest SpA, SApA lub SRL",
+Applicable if the company is a limited liability company,"Stosuje się, jeśli firma jest spółką z ograniczoną odpowiedzialnością",
+Applicable if the company is an Individual or a Proprietorship,"Stosuje się, jeśli firma jest jednostką lub właścicielem",
+Applicant,Petent,
+Applicant Type,Typ Wnioskodawcy,
+Application of Funds (Assets),Aktywa,
+Application period cannot be across two allocation records,Okres aplikacji nie może mieć dwóch rekordów przydziału,
+Application period cannot be outside leave allocation period,Wskazana data nieobecności nie może wykraczać poza zaalokowany okres dla nieobecności,
+Applied,Stosowany,
+Apply Now,Aplikuj teraz,
+Appointment Confirmation,Potwierdzenie spotkania,
+Appointment Duration (mins),Czas trwania spotkania (min),
+Appointment Type,Typ spotkania,
+Appointment {0} and Sales Invoice {1} cancelled,Mianowanie {0} i faktura sprzedaży {1} zostały anulowane,
+Appointments and Encounters,Spotkania i spotkania,
+Appointments and Patient Encounters,Spotkania i spotkania z pacjentami,
+Appraisal {0} created for Employee {1} in the given date range,Ocena {0} utworzona dla Pracownika {1} w datach od-do,
+Apprentice,Uczeń,
+Approval Status,Status Zatwierdzenia,
+Approval Status must be 'Approved' or 'Rejected',Status Zatwierdzenia musi być 'Zatwierdzono' albo 'Odrzucono',
+Approve,Zatwierdzać,
+Approving Role cannot be same as role the rule is Applicable To,Rola Zatwierdzająca nie może być taka sama jak rola którą zatwierdza,
+Approving User cannot be same as user the rule is Applicable To,"Zatwierdzający Użytkownik nie może być taki sam, jak użytkownik którego zatwierdza",
+"Apps using current key won't be able to access, are you sure?","Aplikacje używające obecnego klucza nie będą mogły uzyskać dostępu, czy na pewno?",
+Are you sure you want to cancel this appointment?,Czy na pewno chcesz anulować to spotkanie?,
+Arrear,Zaległość,
+As Examiner,Jako egzaminator,
+As On Date,W sprawie daty,
+As Supervisor,Jako Supervisor,
+As per rules 42 & 43 of CGST Rules,Zgodnie z zasadami 42 i 43 Regulaminu CGST,
+As per section 17(5),Jak w sekcji 17 (5),
+As per your assigned Salary Structure you cannot apply for benefits,Zgodnie z przypisaną Ci strukturą wynagrodzeń nie możesz ubiegać się o świadczenia,
+Assessment,Oszacowanie,
+Assessment Criteria,Kryteria oceny,
+Assessment Group,Grupa Assessment,
+Assessment Group: ,Grupa oceny:,
+Assessment Plan,Plan oceny,
+Assessment Plan Name,Nazwa planu oceny,
+Assessment Report,Sprawozdanie z oceny,
+Assessment Reports,Raporty z oceny,
+Assessment Result,Wynik oceny,
+Assessment Result record {0} already exists.,Wynik Wynik {0} już istnieje.,
+Asset,Składnik aktywów,
+Asset Category,Aktywa Kategoria,
+Asset Category is mandatory for Fixed Asset item,Kategoria atutem jest obowiązkowe dla Fixed pozycja aktywów,
+Asset Maintenance,Konserwacja aktywów,
+Asset Movement,Zaleta Ruch,
+Asset Movement record {0} created,Rekord Ruch atutem {0} tworzone,
+Asset Name,Zaleta Nazwa,
+Asset Received But Not Billed,"Zasoby odebrane, ale nieopłacone",
+Asset Value Adjustment,Korekta wartości aktywów,
+"Asset cannot be cancelled, as it is already {0}","Aktywów nie mogą być anulowane, ponieważ jest już {0}",
+Asset scrapped via Journal Entry {0},Zaleta złomowany poprzez Journal Entry {0},
+"Asset {0} cannot be scrapped, as it is already {1}","Składnik {0} nie może zostać wycofane, jak to jest już {1}",
+Asset {0} does not belong to company {1},Zaleta {0} nie należą do firmy {1},
+Asset {0} must be submitted,Zaleta {0} należy składać,
+Assets,Majątek,
+Assign,Przydziel,
+Assign Salary Structure,Przypisanie struktury wynagrodzeń,
+Assign To,Przypisano do,
+Assign to Employees,Przypisz do pracowników,
+Assigning Structures...,Przyporządkowywanie Struktur,
+Associate,Współpracownik,
+At least one mode of payment is required for POS invoice.,Co najmniej jeden tryb płatności POS jest wymagane dla faktury.,
+Atleast one item should be entered with negative quantity in return document,Conajmniej jedna pozycja powinna być wpisana w ilości negatywnej w dokumencie powrotnej,
+Atleast one of the Selling or Buying must be selected,Conajmniej jeden sprzedaż lub zakup musi być wybrany,
+Atleast one warehouse is mandatory,Co najmniej jeden magazyn jest wymagany,
+Attach Logo,Załącz Logo,
+Attachment,Załącznik,
+Attachments,Załączniki,
+Attendance,Obecność,
+Attendance From Date and Attendance To Date is mandatory,Obecnośc od i do Daty są obowiązkowe,
+Attendance can not be marked for future dates,Obecność nie może być oznaczana na przyszłość,
+Attendance date can not be less than employee's joining date,data frekwencja nie może być mniejsza niż data łączącej pracownika,
+Attendance for employee {0} is already marked,Frekwencja pracownika {0} jest już zaznaczona,
+Attendance for employee {0} is already marked for this day,Frekwencja na pracownika {0} jest już zaznaczone na ten dzień,
+Attendance has been marked successfully.,Obecność została oznaczona pomyślnie.,
+Attendance not submitted for {0} as it is a Holiday.,"Frekwencja nie została przesłana do {0}, ponieważ jest to święto.",
+Attendance not submitted for {0} as {1} on leave.,Obecność nie została przesłana do {0} jako {1} podczas nieobecności.,
+Attribute table is mandatory,Stół atrybut jest obowiązkowy,
+Attribute {0} selected multiple times in Attributes Table,Atrybut {0} wybrane atrybuty kilka razy w tabeli,
+Author,Autor,
+Authorized Signatory,Upoważniony sygnatariusz,
+Auto Material Requests Generated,Wnioski Auto Materiał Generated,
+Auto Repeat,Auto Repeat,
+Auto repeat document updated,Automatycznie powtórzony dokument został zaktualizowany,
+Available,Dostępny,
+Available Leaves,Dostępne Nieobecności,
+Available Qty,Dostępne szt,
+Available Selling,Dostępne sprzedawanie,
+Available for use date is required,Dostępna jest data przydatności do użycia,
+Available slots,Dostępne gniazda,
+Available {0},Dostępne {0},
+Available-for-use Date should be after purchase date,Data przydatności do użycia powinna być późniejsza niż data zakupu,
+Average Age,Średni wiek,
+Average Rate,Średnia Stawka,
+Avg Daily Outgoing,Średnia dzienna Wychodzące,
+Avg. Buying Price List Rate,Śr. Kupowanie kursu cenowego,
+Avg. Selling Price List Rate,Śr. Wskaźnik cen sprzedaży,
+Avg. Selling Rate,Średnia. Cena sprzedaży,
+BOM,BOM,
+BOM Browser,Przeglądarka BOM,
+BOM No,Nr zestawienia materiałowego,
+BOM Rate,BOM Kursy,
+BOM Stock Report,BOM Zdjęcie Zgłoś,
+BOM and Manufacturing Quantity are required,BOM i ilości są wymagane Manufacturing,
+BOM does not contain any stock item,BOM nie zawiera żadnego elementu akcji,
+BOM {0} does not belong to Item {1},BOM {0} nie należy do pozycji {1},
+BOM {0} must be active,BOM {0} musi być aktywny,
+BOM {0} must be submitted,BOM {0} musi być złożony,
+Balance,Bilans,
+Balance (Dr - Cr),Balans (Dr - Cr),
+Balance ({0}),Saldo ({0}),
+Balance Qty,Ilość bilansu,
+Balance Sheet,Arkusz Bilansu,
+Balance Value,Wartość bilansu,
+Balance for Account {0} must always be {1},Bilans dla Konta {0} zawsze powinien wynosić {1},
+Bank,Bank,
+Bank Account,Konto bankowe,
+Bank Accounts,Konta bankowe,
+Bank Draft,Przekaz bankowy,
+Bank Entries,Operacje bankowe,
+Bank Name,Nazwa banku,
+Bank Overdraft Account,Konto z kredytem w rachunku bankowym,
+Bank Reconciliation,Uzgodnienia z wyciągiem bankowym,
+Bank Reconciliation Statement,Stan uzgodnień z wyciągami z banku,
+Bank Statement,Wyciąg bankowy,
+Bank Statement Settings,Ustawienia wyciągu bankowego,
+Bank Statement balance as per General Ledger,Bilans wyciągów bankowych wedle Księgi Głównej,
+Bank account cannot be named as {0},Rachunku bankowego nie może być nazwany {0},
+Bank/Cash transactions against party or for internal transfer,Transakcje Bank / Gotówka przeciwko osobie lub do przenoszenia wewnętrznego,
+Banking,Bankowość,
+Banking and Payments,Operacje bankowe i płatności,
+Barcode {0} already used in Item {1},Kod kreskowy {0} jest już używany dla przedmiotu {1},
+Barcode {0} is not a valid {1} code,Kod kreskowy {0} nie jest prawidłowym kodem {1},
+Base,Baza,
+Base URL,Podstawowy adres URL,
+Based On,Bazujący na,
+Based On Payment Terms,Bazując na Zasadach Płatności,
+Basic,Podstawowy,
+Batch,Partia,
+Batch Entries,Wpisy wsadowe,
+Batch ID is mandatory,Identyfikator zbiorczy jest obowiązkowy,
+Batch Inventory,Inwentaryzacja partii,
+Batch Name,Batch Nazwa,
+Batch No,Nr Partii,
+Batch number is mandatory for Item {0},Numer partii jest obowiązkowy dla produktu {0},
+Batch {0} of Item {1} has expired.,Batch {0} pozycji {1} wygasł.,
+Batch {0} of Item {1} is disabled.,Partia {0} elementu {1} jest wyłączona.,
+Batch: ,Partia:,
+Batches,Partie,
+Become a Seller,Zostań sprzedawcą,
+Beginner,Początkujący,
+Bill,Rachunek,
+Bill Date,Data Rachunku,
+Bill No,Numer Rachunku,
+Bill of Materials,Zestawienie materiałów,
+Bill of Materials (BOM),Zestawienie materiałowe (BOM),
+Billable Hours,Rozliczalne godziny,
+Billed,Rozliczony,
+Billed Amount,Ilość Rozliczenia,
+Billing,Dane do faktury,
+Billing Address,Adres Faktury,
+Billing Address is same as Shipping Address,"Adres rozliczeniowy jest taki sam, jak adres wysyłki",
+Billing Amount,Kwota Rozliczenia,
+Billing Status,Status Faktury,
+Billing currency must be equal to either default company's currency or party account currency,Waluta rozliczeniowa musi być równa domyślnej walucie firmy lub walucie konta strony,
+Bills raised by Suppliers.,Rachunki od dostawców.,
+Bills raised to Customers.,Rachunki dla klientów.,
+Biotechnology,Biotechnologia,
+Birthday Reminder,Przypomnienie o urodzinach,
+Black,czarny,
+Blanket Orders from Costumers.,Zamówienia zbiorcze od klientów.,
+Block Invoice,Zablokuj fakturę,
+Boms,Bomy,
+Bonus Payment Date cannot be a past date,Data płatności premii nie może być datą przeszłą,
+Both Trial Period Start Date and Trial Period End Date must be set,"Należy ustawić zarówno datę rozpoczęcia okresu próbnego, jak i datę zakończenia okresu próbnego",
+Both Warehouse must belong to same Company,Obydwa Magazyny muszą należeć do tej samej firmy,
+Branch,Odddział,
+Broadcasting,Transmitowanie,
+Brokerage,Pośrednictwo,
+Browse BOM,Przeglądaj BOM,
+Budget Against,budżet Against,
+Budget List,Lista budżetu,
+Budget Variance Report,Raport z weryfikacji budżetu,
+Budget cannot be assigned against Group Account {0},Budżet nie może być przypisany do rachunku grupy {0},
+"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Budżet nie może być przypisany przed {0}, ponieważ nie jest to konto przychodów lub kosztów",
+Buildings,Budynki,
+Bundle items at time of sale.,Pakiet przedmiotów w momencie sprzedaży,
+Business Development Manager,Business Development Manager,
+Buy,Kup,
+Buying,Zakupy,
+Buying Amount,Kwota zakupu,
+Buying Price List,Kupowanie cennika,
+Buying Rate,Cena zakupu,
+"Buying must be checked, if Applicable For is selected as {0}","Zakup musi być sprawdzona, jeśli dotyczy wybrano jako {0}",
+By {0},Do {0},
+Bypass credit check at Sales Order ,Pomiń kontrolę kredytową w zleceniu sprzedaży,
+C-Form records,C-forma rekordy,
+C-form is not applicable for Invoice: {0},C-forma nie ma zastosowania do faktury: {0},
+CEO,CEO,
+CESS Amount,Kwota CESS,
+CGST Amount,CGST Kwota,
+CRM,CRM,
+CWIP Account,Konto CWIP,
+Calculated Bank Statement balance,Obliczony bilans wyciągu bankowego,
+Calls,Połączenia,
+Campaign,Kampania,
+Can be approved by {0},Może być zatwierdzone przez {0},
+"Can not filter based on Account, if grouped by Account","Nie można przefiltrować na podstawie Konta, jeśli pogrupowano z użuciem konta",
+"Can not filter based on Voucher No, if grouped by Voucher","Nie można przefiltrować wg Podstawy, jeśli pogrupowano z użyciem Podstawy",
+"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Nie można oznaczyć rekordu rozładowania szpitala, istnieją niezafakturowane faktury {0}",
+Can only make payment against unbilled {0},Mogą jedynie wpłaty przed Unbilled {0},
+Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Może odnosić się do wierdza tylko wtedy, gdy typ opłata jest ""Poprzedniej Wartości Wiersza Suma"" lub ""poprzedniego wiersza Razem""",
+"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Nie można zmienić metody wyceny, ponieważ istnieją transakcje dotyczące niektórych pozycji, które nie mają własnej metody wyceny",
+Can't create standard criteria. Please rename the criteria,Nie można utworzyć standardowych kryteriów. Zmień nazwę kryteriów,
+Cancel,Anuluj,
+Cancel Material Visit {0} before cancelling this Warranty Claim,Anuluj Materiał Odwiedź {0} zanim anuluje to roszczenia z tytułu gwarancji,
+Cancel Material Visits {0} before cancelling this Maintenance Visit,Anuluj Fizyczne Wizyty {0} zanim anulujesz Wizytę Pośrednią,
+Cancel Subscription,Anuluj subskrypcje,
+Cancel the journal entry {0} first,Najpierw anuluj zapis księgowy {0},
+Canceled,Anulowany,
+"Cannot Submit, Employees left to mark attendance","Nie można przesłać, pracownicy zostali pozostawieni, aby zaznaczyć frekwencję",
+Cannot be a fixed asset item as Stock Ledger is created.,"Nie może być pozycją środka trwałego, ponieważ tworzona jest księga zapasowa.",
+Cannot cancel because submitted Stock Entry {0} exists,"Nie można anulować, ponieważ wskazane Wprowadzenie na magazyn {0} istnieje",
+Cannot cancel transaction for Completed Work Order.,Nie można anulować transakcji dotyczącej ukończonego zlecenia pracy.,
+Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},"Nie można anulować {0} {1}, ponieważ numer seryjny {2} nie należy do magazynu {3}",
+Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Nie można zmienić atrybutów po transakcji giełdowej. Zrób nowy przedmiot i prześlij towar do nowego przedmiotu,
+Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,"Nie można zmienić Rok obrotowy Data rozpoczęcia i Data zakończenia roku obrotowego, gdy rok obrotowy jest zapisane.",
+Cannot change Service Stop Date for item in row {0},Nie można zmienić daty zatrzymania usługi dla pozycji w wierszu {0},
+Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,"Nie można zmienić właściwości wariantu po transakcji giełdowej. Będziesz musiał zrobić nową rzecz, aby to zrobić.",
+"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Nie można zmienić domyślnej waluty firmy, ponieważ istnieją przypisane do niej transakcje. Anuluj transakcje, aby zmienić domyślną walutę",
+Cannot change status as student {0} is linked with student application {1},Nie można zmienić status studenta {0} jest powiązany z aplikacją studentów {1},
+Cannot convert Cost Center to ledger as it has child nodes,"Nie można przekonwertować centrum kosztów do księgi głównej, jak to ma węzły potomne",
+Cannot covert to Group because Account Type is selected.,"Nie można konwertowanie do grupy, ponieważ jest wybrany rodzaj konta.",
+Cannot create Retention Bonus for left Employees,Nie można utworzyć bonusu utrzymania dla leworęcznych pracowników,
+Cannot create a Delivery Trip from Draft documents.,Nie można utworzyć podróży dostawy z dokumentów roboczych.,
+Cannot deactivate or cancel BOM as it is linked with other BOMs,Nie można wyłączyć lub anulować LM jak to jest połączone z innymi LM,
+"Cannot declare as lost, because Quotation has been made.",Nie można zadeklarować jako zagubiony z powodu utworzenia kwotacji,
+Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Nie można wywnioskować, kiedy kategoria dotyczy ""Ocena"" a kiedy ""Oceny i Total""",
+Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',"Nie można odliczyć, gdy kategoria jest dla &#39;Wycena&#39; lub &#39;Vaulation i Total&#39;",
+"Cannot delete Serial No {0}, as it is used in stock transactions","Nie można usunąć nr seryjnego {0}, ponieważ jest wykorzystywany w transakcjach magazynowych",
+Cannot enroll more than {0} students for this student group.,Nie można zapisać więcej niż {0} studentów dla tej grupy studentów.,
+Cannot find active Leave Period,Nie można znaleźć aktywnego Okresu Nieobecności,
+Cannot produce more Item {0} than Sales Order quantity {1},Nie można wyprodukować więcej przedmiotów {0} niż wartość {1} na Zamówieniu,
+Cannot promote Employee with status Left,Nie można promować pracownika z pozostawionym statusem,
+Cannot refer row number greater than or equal to current row number for this Charge type,Nie można wskazać numeru wiersza większego lub równego numerowi dla tego typu Opłaty,
+Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Nie można wybrać typu opłaty jako ""Sumy Poprzedniej Komórki"" lub ""Całkowitej kwoty poprzedniej Komórki"" w pierwszym rzędzie",
+Cannot set as Lost as Sales Order is made.,Nie można ustawić jako Utracone Zamówienia Sprzedaży,
+Cannot set authorization on basis of Discount for {0},Nie można ustawić autoryzacji na podstawie Zniżki dla {0},
+Cannot set multiple Item Defaults for a company.,Nie można ustawić wielu wartości domyślnych dla danej firmy.,
+Cannot set quantity less than delivered quantity,Nie można ustawić ilości mniejszej niż dostarczona ilość,
+Cannot set quantity less than received quantity,Nie można ustawić ilości mniejszej niż ilość odebrana,
+Cannot set the field <b>{0}</b> for copying in variants,Nie można ustawić pola <b>{0}</b> do kopiowania w wariantach,
+Cannot transfer Employee with status Left,Nie można przenieść pracownika ze statusem w lewo,
+Cannot {0} {1} {2} without any negative outstanding invoice,Nie można {0} {1} {2} bez negatywnego wybitne faktury,
+Capital Equipments,Wyposażenie Kapitałowe,
+Capital Stock,Kapitał zakładowy,
+Capital Work in Progress,Praca kapitałowa w toku,
+Cart,Koszyk,
+Cart is Empty,Koszyk jest pusty,
+Case No(s) already in use. Try from Case No {0},Numer(y) sprawy w użytku. Proszę spróbować Numer Sprawy {0},
+Cash,Gotówka,
+Cash Flow Statement,Raport kasowy,
+Cash Flow from Financing,Cash Flow z finansowania,
+Cash Flow from Investing,Przepływy środków pieniężnych z Inwestowanie,
+Cash Flow from Operations,Przepływy środków pieniężnych z działalności operacyjnej,
+Cash In Hand,Gotówka w kasie,
+Cash or Bank Account is mandatory for making payment entry,Konto Gotówka lub Bank jest wymagane dla tworzenia zapisów Płatności,
+Cashier Closing,Zamknięcie kasjera,
+Casual Leave,Urlop okolicznościowy,
+Category,Kategoria,
+Category Name,Nazwa kategorii,
+Caution,Uwaga,
+Central Tax,Podatek centralny,
+Certification,Orzecznictwo,
+Cess,Cess,
+Change Amount,Zmień Kwota,
+Change Item Code,Zmień kod przedmiotu,
+Change Release Date,Zmień datę wydania,
+Change Template Code,Zmień kod szablonu,
+Changing Customer Group for the selected Customer is not allowed.,Zmiana grupy klientów dla wybranego klienta jest niedozwolona.,
+Chapter,Rozdział,
+Chapter information.,Informacje o rozdziale.,
+Charge of type 'Actual' in row {0} cannot be included in Item Rate,Opłata typu 'Aktualny' w wierszu {0} nie może być uwzględniona w cenie pozycji,
+Chargeble,Chargeble,
+Charges are updated in Purchase Receipt against each item,Opłaty są aktualizowane w ZAKUPU każdej pozycji,
+"Charges will be distributed proportionately based on item qty or amount, as per your selection","Koszty zostaną rozdzielone proporcjonalnie na podstawie Ilość pozycji lub kwoty, jak na swój wybór",
+Chart of Cost Centers,Struktura kosztów (MPK),
+Check all,Zaznacz wszystkie,
+Checkout,Sprawdzić,
+Chemical,Chemiczny,
+Cheque,Czek,
+Cheque/Reference No,Czek / numer,
+Cheques Required,Wymagane kontrole,
+Cheques and Deposits incorrectly cleared,Czeki i Depozyty nieprawidłowo rozliczone,
+Child Task exists for this Task. You can not delete this Task.,Dla tego zadania istnieje zadanie podrzędne. Nie możesz usunąć tego zadania.,
+Child nodes can be only created under 'Group' type nodes,węzły potomne mogą być tworzone tylko w węzłach typu &quot;grupa&quot;,
+Child warehouse exists for this warehouse. You can not delete this warehouse.,Magazyn Dziecko nie istnieje dla tego magazynu. Nie można usunąć tego magazynu.,
+Circular Reference Error,Circular Error Referencje,
+City,Miasto,
+City/Town,Miasto/Miejscowość,
+Claimed Amount,Kwota roszczenia,
+Clay,Glina,
+Clear filters,Wyczyść filtry,
+Clear values,Wyczyść wartości,
+Clearance Date,Data Czystki,
+Clearance Date not mentioned,Rozliczenie Data nie została podana,
+Clearance Date updated,Rozliczenie Data aktualizacji,
+Client,Klient,
+Client ID,Identyfikator klienta,
+Client Secret,Klient Secret,
+Clinical Procedure,Procedura kliniczna,
+Clinical Procedure Template,Szablon procedury klinicznej,
+Close Balance Sheet and book Profit or Loss.,Sporządzenie Bilansu oraz Rachunku zysków i strat.,
+Close Loan,Zamknij pożyczkę,
+Close the POS,Zamknij punkt sprzedaży,
+Closed,Zamknięte,
+Closed order cannot be cancelled. Unclose to cancel.,Kolejność Zamknięty nie mogą być anulowane. Unclose aby anulować.,
+Closing (Cr),Zamknięcie (Cr),
+Closing (Dr),Zamknięcie (Dr),
+Closing (Opening + Total),Zamknięcie (otwarcie + suma),
+Closing Account {0} must be of type Liability / Equity,Zamknięcie konta {0} musi być typu odpowiedzialności / Equity,
+Closing Balance,Bilans zamknięcia,
+Code,Kod,
+Collapse All,Zwinąć wszystkie,
+Color,Kolor,
+Colour,Kolor,
+Combined invoice portion must equal 100%,Łączna kwota faktury musi wynosić 100%,
+Commercial,Komercyjny,
+Commission,Prowizja,
+Commission Rate %,Stawka prowizji%,
+Commission on Sales,Prowizja od sprzedaży,
+Commission rate cannot be greater than 100,Wartość prowizji nie może być większa niż 100,
+Community Forum,Społeczność Forum,
+Company (not Customer or Supplier) master.,Informacje o własnej firmie.,
+Company Abbreviation,Nazwa skrótowa firmy,
+Company Abbreviation cannot have more than 5 characters,Skrót firmy nie może zawierać więcej niż 5 znaków,
+Company Name,Nazwa firmy,
+Company Name cannot be Company,Nazwa firmy nie może być firmą,
+Company currencies of both the companies should match for Inter Company Transactions.,Waluty firmy obu spółek powinny być zgodne z Transakcjami między spółkami.,
+Company is manadatory for company account,Firma jest manadatory dla konta firmowego,
+Company name not same,Nazwa firmy nie jest taka sama,
+Company {0} does not exist,Firma {0} nie istnieje,
+Compensatory Off,Urlop wyrównawczy,
+Compensatory leave request days not in valid holidays,Dni urlopu wyrównawczego nie zawierają się w zakresie prawidłowych dniach świątecznych,
+Complaint,Skarga,
+Completion Date,Data ukończenia,
+Computer,Komputer,
+Condition,Stan,
+Configure,Konfiguruj,
+Configure {0},Konfiguruj {0},
+Confirmed orders from Customers.,Potwierdzone zamówienia od klientów,
+Connect Amazon with ERPNext,Połącz Amazon z ERPNext,
+Connect Shopify with ERPNext,Połącz Shopify z ERPNext,
+Connect to Quickbooks,Połącz się z Quickbooks,
+Connected to QuickBooks,Połączony z QuickBooks,
+Connecting to QuickBooks,Łączenie z QuickBookami,
+Consultation,Konsultacja,
+Consultations,Konsultacje,
+Consulting,Konsulting,
+Consumable,Konsumpcyjny,
+Consumed,Skonsumowano,
+Consumed Amount,Skonsumowana wartość,
+Consumed Qty,Skonsumowana ilość,
+Consumer Products,Produkty konsumenckie,
+Contact,Kontakt,
+Contact Details,Szczegóły kontaktu,
+Contact Number,Numer kontaktowy,
+Contact Us,Skontaktuj się z nami,
+Content,Zawartość,
+Content Masters,Mistrzowie treści,
+Content Type,Typ zawartości,
+Continue Configuration,Kontynuuj konfigurację,
+Contract,Kontrakt,
+Contract End Date must be greater than Date of Joining,Końcowa data kontraktu musi być większa od Daty Członkowstwa,
+Contribution %,Udział %,
+Contribution Amount,Kwota udziału,
+Conversion factor for default Unit of Measure must be 1 in row {0},Współczynnikiem konwersji dla domyślnej Jednostki Pomiaru musi być 1 w rzędzie {0},
+Conversion rate cannot be 0 or 1,Wartością konwersji nie może być 0 ani 1,
+Convert to Group,Przekształć w Grupę,
+Convert to Non-Group,Przekształć w nie-Grupę,
+Cosmetics,Kosmetyki,
+Cost Center,Centrum kosztów,
+Cost Center Number,Numer centrum kosztów,
+Cost Center and Budgeting,Centrum kosztów i budżetowanie,
+Cost Center is required in row {0} in Taxes table for type {1},Centrum kosztów jest wymagane w wierszu {0} w tabeli podatków dla typu {1},
+Cost Center with existing transactions can not be converted to group,Centrum Kosztów z istniejącą transakcją nie może być przekształcone w grupę,
+Cost Center with existing transactions can not be converted to ledger,Centrum Kosztów z istniejącą transakcją nie może być przekształcone w rejestr,
+Cost Centers,Centra Kosztów,
+Cost Updated,Koszt Zaktualizowano,
+Cost as on,Kosztować od,
+Cost of Delivered Items,Koszt dostarczonych przedmiotów,
+Cost of Goods Sold,Wartość sprzedanych pozycji w cenie nabycia,
+Cost of Issued Items,Koszt Emitowanych Przedmiotów,
+Cost of New Purchase,Koszt zakupu nowego,
+Cost of Purchased Items,Koszt zakupionych towarów,
+Cost of Scrapped Asset,Koszt złomowany aktywach,
+Cost of Sold Asset,Koszt sprzedanych aktywów,
+Cost of various activities,Koszt różnych działań,
+"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Nie można utworzyć noty kredytowej automatycznie, odznacz opcję &quot;Nota kredytowa&quot; i prześlij ponownie",
+Could not generate Secret,Nie można wygenerować Tajnego,
+Could not retrieve information for {0}.,Nie można pobrać informacji dla {0}.,
+Could not solve criteria score function for {0}. Make sure the formula is valid.,"Nie można rozwiązać funkcji punktacji kryterium dla {0}. Upewnij się, że formuła jest prawidłowa.",
+Could not solve weighted score function. Make sure the formula is valid.,"Nie udało się rozwiązać funkcji ważonych punktów. Upewnij się, że formuła jest prawidłowa.",
+Could not submit some Salary Slips,Nie można przesłać niektórych zwrotów wynagrodzeń,
+"Could not update stock, invoice contains drop shipping item.","Nie można zaktualizować stanu - faktura zawiera pozycję, której proces wysyłki scedowano na dostawcę.",
+Country wise default Address Templates,Szablony Adresów na dany kraj,
+Course,Kurs,
+Course Code: ,Kod kursu:,
+Course Enrollment {0} does not exists,Rejestracja kursu {0} nie istnieje,
+Course Schedule,Plan zajęć,
+Course: ,Kierunek:,
+Cr,Kr,
+Create,Utwórz,
+Create BOM,Utwórz zestawienie komponentów,
+Create Delivery Trip,Utwórz podróż dostawy,
+Create Disbursement Entry,Utwórz wpis wypłaty,
+Create Employee,Utwórz pracownika,
+Create Employee Records,Tworzenie pracownicze Records,
+"Create Employee records to manage leaves, expense claims and payroll","Tworzenie rekordów pracownika do zarządzania nieobecnościami, roszczenia o wydatkach i płac",
+Create Fee Schedule,Utwórz harmonogram opłat,
+Create Fees,Utwórz opłaty,
+Create Inter Company Journal Entry,Utwórz wpis do dziennika firmy,
+Create Invoice,Wystaw fakturę,
+Create Invoices,Utwórz faktury,
+Create Job Card,Utwórz kartę pracy,
+Create Journal Entry,Utwórz wpis do dziennika,
+Create Lead,Utwórz ołów,
+Create Leads,Tworzenie Leads,
+Create Maintenance Visit,Utwórz wizytę serwisową,
+Create Material Request,Utwórz żądanie materiałowe,
+Create Multiple,Utwórz wiele,
+Create Opening Sales and Purchase Invoices,Utwórz otwarcie sprzedaży i faktury zakupu,
+Create Payment Entries,Utwórz wpisy płatności,
+Create Payment Entry,Utwórz wpis płatności,
+Create Print Format,Tworzenie format wydruku,
+Create Purchase Order,Utwórz zamówienie zakupu,
+Create Purchase Orders,Stwórz zamówienie zakupu,
+Create Quotation,Utwórz ofertę,
+Create Salary Slip,Utwórz pasek wynagrodzenia,
+Create Salary Slips,Utwórz wynagrodzenie wynagrodzenia,
+Create Sales Invoice,Utwórz fakturę sprzedaży,
+Create Sales Order,Utwórz zamówienie sprzedaży,
+Create Sales Orders to help you plan your work and deliver on-time,"Twórz zlecenia sprzedaży, aby pomóc Ci zaplanować pracę i dostarczyć terminowość",
+Create Sample Retention Stock Entry,Utwórz wpis dotyczący przechowywania próbki,
+Create Student,Utwórz ucznia,
+Create Student Batch,Utwórz Partię Ucznia,
+Create Student Groups,Tworzenie grup studenckich,
+Create Supplier Quotation,Utwórz ofertę dla dostawców,
+Create Tax Template,Utwórz szablon podatku,
+Create Timesheet,Utwórz grafik,
+Create User,Stwórz użytkownika,
+Create Users,Tworzenie użytkowników,
+Create Variant,Utwórz wariant,
+Create Variants,Tworzenie Warianty,
+"Create and manage daily, weekly and monthly email digests.","Tworzenie i zarządzanie dziennymi, tygodniowymi i miesięcznymi zestawieniami e-mail.",
+Create rules to restrict transactions based on values.,Tworzenie reguł ograniczających transakcje na podstawie wartości,
+Create customer quotes,Tworzenie cytaty z klientami,
+Created {0} scorecards for {1} between: ,Utworzono {0} karty wyników dla {1} między:,
+Creating Company and Importing Chart of Accounts,Tworzenie firmy i importowanie planu kont,
+Creating Fees,Tworzenie opłat,
+Creating Payment Entries......,Tworzenie wpisów płatności ......,
+Creating Salary Slips...,Tworzenie zarobków ...,
+Creating student groups,Tworzenie grup studentów,
+Creating {0} Invoice,Tworzenie faktury {0},
+Credit,Kredyt,
+Credit ({0}),Kredyt ({0}),
+Credit Account,Konto kredytowe,
+Credit Balance,Saldo kredytowe,
+Credit Card,Karta kredytowa,
+Credit Days cannot be a negative number,Dni kredytu nie mogą być liczbą ujemną,
+Credit Limit,Limit kredytowy,
+Credit Note,Nota uznaniowa (kredytowa),
+Credit Note Amount,Kwota noty uznaniowej,
+Credit Note Issued,Credit blanco wystawiony,
+Credit Note {0} has been created automatically,Nota kredytowa {0} została utworzona automatycznie,
+Credit limit has been crossed for customer {0} ({1}/{2}),Limit kredytowy został przekroczony dla klienta {0} ({1} / {2}),
+Creditors,Wierzyciele,
+Criteria weights must add up to 100%,Kryteria wag muszą dodać do 100%,
+Crop Cycle,Crop Cycle,
+Crops & Lands,Uprawy i ziemie,
+Currency Exchange must be applicable for Buying or for Selling.,Wymiana walut musi dotyczyć Kupowania lub Sprzedaży.,
+Currency can not be changed after making entries using some other currency,Waluta nie może być zmieniony po dokonaniu wpisów używając innej walucie,
+Currency exchange rate master.,Główna wartość Wymiany walut,
+Currency for {0} must be {1},Waluta dla {0} musi być {1},
+Currency is required for Price List {0},Waluta jest wymagana dla Cenniku {0},
+Currency of the Closing Account must be {0},Waluta Rachunku Zamknięcie musi być {0},
+Currency of the price list {0} must be {1} or {2},Waluta listy cen {0} musi wynosić {1} lub {2},
+Currency should be same as Price List Currency: {0},"Waluta powinna być taka sama, jak waluta cennika: {0}",
+Current,Bieżący,
+Current Assets,Aktywa finansowe,
+Current BOM and New BOM can not be same,Aktualna BOM i Nowa BOM nie może być taki sam,
+Current Job Openings,Aktualne ofert pracy,
+Current Liabilities,Bieżące Zobowiązania,
+Current Qty,Obecna ilość,
+Current invoice {0} is missing,Brak aktualnej faktury {0},
+Custom HTML,Niestandardowy HTML,
+Custom?,Niestandardowy?,
+Customer,Klient,
+Customer Addresses And Contacts,Klienci Adresy i kontakty,
+Customer Contact,Kontakt z klientem,
+Customer Database.,Baza danych klientów.,
+Customer Group,Grupa klientów,
+Customer LPO,Klient LPO,
+Customer LPO No.,Numer klienta LPO,
+Customer Name,Nazwa klienta,
+Customer POS Id,Identyfikator klienta klienta,
+Customer Service,Obsługa klienta,
+Customer and Supplier,Klient i dostawca,
+Customer is required,Klient jest wymagany,
+Customer isn't enrolled in any Loyalty Program,Klient nie jest zarejestrowany w żadnym Programie Lojalnościowym,
+Customer required for 'Customerwise Discount',Klient wymagany dla 'Klientwise Discount',
+Customer {0} does not belong to project {1},Klient {0} nie należy do projektu {1},
+Customer {0} is created.,Utworzono klienta {0}.,
+Customers in Queue,Klienci w kolejce,
+Customize Homepage Sections,Dostosuj sekcje strony głównej,
+Customizing Forms,Dostosowywanie formularzy,
+Daily Project Summary for {0},Codzienne podsumowanie projektu dla {0},
+Daily Reminders,Codzienne przypomnienia,
+Daily Work Summary,Dziennie Podsumowanie zawodowe,
+Daily Work Summary Group,Codzienna grupa podsumowująca pracę,
+Data Import and Export,Import i eksport danych,
+Data Import and Settings,Import i ustawienia danych,
+Database of potential customers.,Baza danych potencjalnych klientów.,
+Date Format,Format daty,
+Date Of Retirement must be greater than Date of Joining,Data przejścia na emeryturę musi być większa niż Data wstąpienia,
+Date is repeated,Data jest powtórzona,
+Date of Birth,Data urodzenia,
+Date of Birth cannot be greater than today.,Data urodzenia nie może być większa niż data dzisiejsza.,
+Date of Commencement should be greater than Date of Incorporation,Data rozpoczęcia powinna być większa niż data założenia,
+Date of Joining,Data Wstąpienia,
+Date of Joining must be greater than Date of Birth,Data Wstąpienie musi być większa niż Data Urodzenia,
+Date of Transaction,Data transakcji,
+Datetime,Data-czas,
+Day,Dzień,
+Debit,Debet,
+Debit ({0}),Debet ({0}),
+Debit A/C Number,Numer A / C debetu,
+Debit Account,Konto debetowe,
+Debit Note,Nota debetowa,
+Debit Note Amount,Kwota noty debetowej,
+Debit Note Issued,Nocie debetowej,
+Debit To is required,Debetowane Konto jest wymagane,
+Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debetowe i kredytowe nie równe dla {0} # {1}. Różnica jest {2}.,
+Debtors,Dłużnicy,
+Debtors ({0}),Dłużnicy ({0}),
+Declare Lost,Zadeklaruj Zagubiony,
+Deduction,Odliczenie,
+Default Activity Cost exists for Activity Type - {0},Istnieje Domyślnie aktywny Koszt rodzajów działalności - {0},
+Default BOM ({0}) must be active for this item or its template,Domyślnie Wykaz Materiałów ({0}) musi być aktywny dla tej pozycji lub jej szablonu,
+Default BOM for {0} not found,Domyślnie BOM dla {0} Nie znaleziono,
+Default BOM not found for Item {0} and Project {1},Domyślnie nie znaleziono elementu BOM dla elementu {0} i projektu {1},
+Default Letter Head,Domyślny nagłówek pisma,
+Default Tax Template,Domyślny szablon podatkowy,
+Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Domyślnie Jednostka miary dla pozycji {0} nie może być zmieniana bezpośrednio, ponieważ masz już jakąś transakcję (y) z innym UOM. Musisz utworzyć nowy obiekt, aby użyć innego domyślnego UOM.",
+Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',"Domyślne jednostki miary dla wariantu &quot;{0}&quot; musi być taki sam, jak w szablonie &#39;{1}&#39;",
+Default settings for buying transactions.,Domyślne ustawienia dla transakcji kupna,
+Default settings for selling transactions.,Domyślne ustawienia dla transakcji sprzedaży,
+Default tax templates for sales and purchase are created.,Definiowane są domyślne szablony podatkowe dla sprzedaży i zakupu.,
+Defaults,Wartości domyślne,
+Defense,Obrona,
+Define Project type.,Zdefiniuj typ projektu.,
+Define budget for a financial year.,Definiowanie budżetu za dany rok budżetowy.,
+Define various loan types,Definiować różne rodzaje kredytów,
+Del,Del,
+Delay in payment (Days),Opóźnienie w płatności (dni),
+Delete all the Transactions for this Company,"Usuń wszystkie transakcje, dla tej firmy",
+Deletion is not permitted for country {0},Usunięcie jest niedozwolone w przypadku kraju {0},
+Delivered,Dostarczono,
+Delivered Amount,Dostarczone Ilość,
+Delivered Qty,Dostarczona Liczba jednostek,
+Delivered: {0},Dostarczone: {0},
+Delivery,Dostarczanie,
+Delivery Date,Data dostawy,
+Delivery Note,Dowód dostawy,
+Delivery Note {0} is not submitted,Dowód dostawy {0} nie został wysłany,
+Delivery Note {0} must not be submitted,Dowód dostawy {0} nie może być wysłany,
+Delivery Notes {0} must be cancelled before cancelling this Sales Order,Dowody Dostawy {0} muszą być anulowane przed anulowanie Zamówienia Sprzedaży,
+Delivery Notes {0} updated,Zaktualizowano uwagi dotyczące dostawy {0},
+Delivery Status,Status dostawy,
+Delivery Trip,Podróż dostawy,
+Delivery warehouse required for stock item {0},Dostawa wymagane dla magazynu pozycji magazynie {0},
+Department,Departament,
+Department Stores,Sklepy detaliczne,
+Depreciation,Amortyzacja,
+Depreciation Amount,Kwota amortyzacji,
+Depreciation Amount during the period,Kwota amortyzacji w okresie,
+Depreciation Date,amortyzacja Data,
+Depreciation Eliminated due to disposal of assets,Amortyzacja Wyeliminowany z tytułu zbycia aktywów,
+Depreciation Entry,Amortyzacja,
+Depreciation Method,Metoda amortyzacji,
+Depreciation Row {0}: Depreciation Start Date is entered as past date,Wiersz amortyzacji {0}: Data rozpoczęcia amortyzacji jest wprowadzana jako data przeszła,
+Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Wiersz amortyzacji {0}: oczekiwana wartość po okresie użyteczności musi być większa lub równa {1},
+Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Wiersz amortyzacji {0}: Data następnej amortyzacji nie może być wcześniejsza niż data przydatności do użycia,
+Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Wiersz amortyzacji {0}: Data następnej amortyzacji nie może być wcześniejsza niż Data zakupu,
+Designer,Projektant,
+Detailed Reason,Szczegółowy powód,
+Details,Szczegóły,
+Details of Outward Supplies and inward supplies liable to reverse charge,Szczegóły dotyczące dostaw zewnętrznych i dostaw wewnętrznych podlegających zwrotnemu obciążeniu,
+Details of the operations carried out.,Szczegóły dotyczące przeprowadzonych operacji.,
+Diagnosis,Diagnoza,
+Did not find any item called {0},Nie znaleziono żadnych pozycji o nazwie {0},
+Diff Qty,Diff Qty,
+Difference Account,Konto Różnic,
+"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Konto różnica musi być kontem typu aktywami / pasywami, ponieważ Zdjęcie Pojednanie jest Wejście otwarcia",
+Difference Amount,Kwota różnicy,
+Difference Amount must be zero,Różnica Kwota musi wynosić zero,
+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.,"Różne UOM dla pozycji prowadzi do nieprawidłowych (Całkowity) Waga netto wartość. Upewnij się, że Waga netto każdej pozycji jest w tej samej UOM.",
+Direct Expenses,Wydatki bezpośrednie,
+Direct Income,Przychody bezpośrednie,
+Disable,Wyłącz,
+Disabled template must not be default template,Szablon niepełnosprawnych nie może być domyślny szablon,
+Disburse Loan,Wypłata pożyczki,
+Disbursed,Wypłacony,
+Disc,Dysk,
+Discharge,Rozładować się,
+Discount,Zniżka (rabat),
+Discount Percentage can be applied either against a Price List or for all Price List.,Rabat procentowy może być stosowany zarówno przed cenniku dla wszystkich Cenniku.,
+Discount must be less than 100,Zniżka musi wynosić mniej niż 100,
+Diseases & Fertilizers,Choroby i nawozy,
+Dispatch,Wyślij,
+Dispatch Notification,Powiadomienie o wysyłce,
+Dispatch State,Państwo wysyłki,
+Distance,Dystans,
+Distribution,Dystrybucja,
+Distributor,Dystrybutor,
+Dividends Paid,Dywidendy wypłacone,
+Do you really want to restore this scrapped asset?,Czy na pewno chcesz przywrócić złomowane atut?,
+Do you really want to scrap this asset?,Czy naprawdę chcemy zlikwidować ten atut?,
+Do you want to notify all the customers by email?,Czy chcesz powiadomić wszystkich klientów pocztą e-mail?,
+Doc Date,Doc Data,
+Doc Name,Doc Name,
+Doc Type,Doc Type,
+Docs Search,Wyszukiwanie dokumentów,
+Document Name,Nazwa dokumentu,
+Document Status,Stan dokumentu,
+Document Type,Typ Dokumentu,
+Domain,Domena,
+Domains,Domeny,
+Done,Gotowe,
+Donor,Dawca,
+Donor Type information.,Informacje o typie dawcy.,
+Donor information.,Informacje o dawcy.,
+Download JSON,Pobierz JSON,
+Draft,Wersja robocza,
+Drop Ship,Drop Ship,
+Drug,Narkotyk,
+Due / Reference Date cannot be after {0},Data referencyjne / Termin nie może być po {0},
+Due Date cannot be before Posting / Supplier Invoice Date,"Data ""do"" nie może być przed datą faktury Opublikowania / Dostawcy",
+Due Date is mandatory,Due Date jest obowiązkowe,
+Duplicate Entry. Please check Authorization Rule {0},Wpis zduplikowany. Proszę sprawdzić zasadę autoryzacji {0},
+Duplicate Serial No entered for Item {0},Zduplikowany Nr Seryjny wprowadzony dla przedmiotu {0},
+Duplicate customer group found in the cutomer group table,Duplikat grupa klientów znajduje się w tabeli grupy cutomer,
+Duplicate entry,Wpis zduplikowany,
+Duplicate item group found in the item group table,Duplikat grupę pozycji w tabeli grupy produktów,
+Duplicate roll number for student {0},Duplikat numeru rolki dla ucznia {0},
+Duplicate row {0} with same {1},Wiersz zduplikowany {0} z tym samym {1},
+Duplicate {0} found in the table,Duplikat {0} znaleziony w tabeli,
+Duration in Days,Czas trwania w dniach,
+Duties and Taxes,Podatki i cła,
+E-Invoicing Information Missing,Brak informacji o e-fakturowaniu,
+ERPNext Demo,ERPNext Demo,
+ERPNext Settings,Ustawienia ERPNext,
+Earliest,Najwcześniejszy,
+Earnest Money,Pieniądze zaliczkowe,
+Earning,Dochód,
+Edit,Edytować,
+Edit Publishing Details,Edytuj szczegóły publikowania,
+"Edit in full page for more options like assets, serial nos, batches etc.","Edytuj na całej stronie, aby uzyskać więcej opcji, takich jak zasoby, numery seryjne, partie itp.",
+Education,Edukacja,
+Either location or employee must be required,Każda lokalizacja lub pracownik muszą być wymagane,
+Either target qty or target amount is mandatory,Wymagana jest ilość lub kwota docelowa,
+Either target qty or target amount is mandatory.,Wymagana jest ilość lub kwota docelowa,
+Electrical,Elektryczne,
+Electronic Equipments,Urządzenia elektroniczne,
+Electronics,Elektronika,
+Eligible ITC,Kwalifikujące się ITC,
+Email Account,Konto e-mail,
+Email Address,Adres e-mail,
+"Email Address must be unique, already exists for {0}","E-mail musi być unikalny, istnieje już dla {0}",
+Email Digest: ,przetwarzanie maila,
+Email Reminders will be sent to all parties with email contacts,Przypomnienia e-mailem będą wysyłane do wszystkich stron z kontaktami e-mail,
+Email Sent,Wiadomość wysłana,
+Email Template,Szablon e-maila,
+Email not found in default contact,Nie znaleziono wiadomości e-mail w domyślnym kontakcie,
+Email sent to {0},Wiadomość wysłana do {0},
+Employee,Pracownik,
+Employee A/C Number,Numer A / C pracownika,
+Employee Advances,Zaliczki dla pracowników,
+Employee Benefits,Świadczenia pracownicze,
+Employee Grade,Klasa pracownika,
+Employee ID,numer identyfikacyjny pracownika,
+Employee Lifecycle,Cykl życia pracownika,
+Employee Name,Nazwisko pracownika,
+Employee Promotion cannot be submitted before Promotion Date ,Promocji Pracowników nie można przesłać przed datą promocji,
+Employee Referral,Referencje pracownika,
+Employee Transfer cannot be submitted before Transfer Date ,Przeniesienie pracownika nie może zostać przesłane przed datą transferu,
+Employee cannot report to himself.,Pracownik nie może odpowiadać do samego siebie.,
+Employee relieved on {0} must be set as 'Left',pracownik zwalnia się na {0} musi być ustawiony jako 'opuścił',
+Employee {0} already submited an apllication {1} for the payroll period {2},Pracownik {0} przesłał już aplikację {1} na okres rozliczeniowy {2},
+Employee {0} has already applied for {1} between {2} and {3} : ,Pracownik {0} złożył już wniosek o przyznanie {1} między {2} a {3}:,
+Employee {0} has no maximum benefit amount,Pracownik {0} nie ma maksymalnej kwoty świadczenia,
+Employee {0} is not active or does not exist,Pracownik {0} jest nieaktywny lub nie istnieje,
+Employee {0} is on Leave on {1},Pracownik {0} jest Nieobecny w trybie {1},
+Employee {0} of grade {1} have no default leave policy,Pracownik {0} stopnia {1} nie ma domyślnych zasad dotyczących urlopu,
+Employee {0} on Half day on {1},Pracownik {0} na pół dnia na {1},
+Enable,Włączyć,
+Enable / disable currencies.,Włącz/wyłącz waluty.,
+Enabled,Aktywny,
+"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Włączenie &quot;użycie do koszyka&quot;, ponieważ koszyk jest włączony i nie powinno być co najmniej jedna zasada podatkowa w koszyku",
+End Date,Data zakonczenia,
+End Date can not be less than Start Date,Data zakończenia nie może być krótsza niż data rozpoczęcia,
+End Date cannot be before Start Date.,Data zakończenia nie może być wcześniejsza niż data rozpoczęcia.,
+End Year,Koniec roku,
+End Year cannot be before Start Year,Koniec roku nie może być przed rozpoczęciem Roku,
+End on,Podłużnie,
+End time cannot be before start time,Czas zakończenia nie może być wcześniejszy niż czas rozpoczęcia,
+Ends On date cannot be before Next Contact Date.,Kończy się Data nie może być wcześniejsza niż data następnego kontaktu.,
+Energy,Energia,
+Engineer,Inżynier,
+Enough Parts to Build,Wystarczające elementy do budowy,
+Enroll,Zapisać,
+Enrolling student,Zapis uczeń,
+Enrolling students,Zapisywanie studentów,
+Enter depreciation details,Wprowadź szczegóły dotyczące amortyzacji,
+Enter the Bank Guarantee Number before submittting.,Wprowadź numer gwarancyjny banku przed złożeniem wniosku.,
+Enter the name of the Beneficiary before submittting.,Wprowadź nazwę Beneficjenta przed złożeniem wniosku.,
+Enter the name of the bank or lending institution before submittting.,Wprowadź nazwę banku lub instytucji kredytowej przed złożeniem wniosku.,
+Enter value betweeen {0} and {1},Wpisz wartość między {0} a {1},
+Entertainment & Leisure,Rozrywka i relaks,
+Entertainment Expenses,Wydatki na reprezentację,
+Equity,Kapitał własny,
+Error Log,Dziennik błędów,
+Error evaluating the criteria formula,Błąd podczas oceny formuły kryterium,
+Error in formula or condition: {0},Błąd wzoru lub stanu {0},
+Error: Not a valid id?,Błąd: Nie ważne id?,
+Estimated Cost,Szacowany koszt,
+Evaluation,Ocena,
+"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Nawet jeśli istnieje wiele przepisów dotyczących cen o najwyższym priorytecie, a następnie następujące priorytety wewnętrznej są stosowane:",
+Event,Wydarzenie,
+Event Location,Lokalizacja wydarzenia,
+Event Name,Nazwa wydarzenia,
+Exchange Gain/Loss,Wymiana Zysk / Strata,
+Exchange Rate Revaluation master.,Mistrz wyceny kursu wymiany.,
+Exchange Rate must be same as {0} {1} ({2}),"Kurs wymiany muszą być takie same, jak {0} {1} ({2})",
+Excise Invoice,Akcyza Faktura,
+Execution,Wykonanie,
+Executive Search,Szukanie wykonawcze,
+Expand All,Rozwiń wszystkie,
+Expected Delivery Date,Spodziewana data odbioru przesyłki,
+Expected Delivery Date should be after Sales Order Date,Oczekiwana data dostarczenia powinna nastąpić po Dacie Zamówienia Sprzedaży,
+Expected End Date,Spodziewana data końcowa,
+Expected Hrs,Oczekiwany godz,
+Expected Start Date,Spodziewana data startowa,
+Expense,Koszt,
+Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Konto koszty / Różnica ({0}) musi być kontem ""rachunek zysków i strat""",
+Expense Account,Konto Wydatków,
+Expense Claim,Zwrot kosztów,
+Expense Claim for Vehicle Log {0},Koszty Żądanie Vehicle Zaloguj {0},
+Expense Claim {0} already exists for the Vehicle Log,Koszty roszczenie {0} już istnieje dla Zaloguj Pojazdów,
+Expense Claims,Zapotrzebowania na wydatki,
+Expense account is mandatory for item {0},Konto wydatków jest obowiązkowe dla przedmiotu {0},
+Expenses,Wydatki,
+Expenses Included In Asset Valuation,Koszty uwzględnione w wycenie aktywów,
+Expenses Included In Valuation,Zaksięgowane wydatki w wycenie,
+Expired Batches,Wygasłe partie,
+Expires On,Upływa w dniu,
+Expiring On,Wygasający,
+Expiry (In Days),Wygaśnięcie (w dniach),
+Explore,Przeglądaj,
+Export E-Invoices,Eksportuj e-faktury,
+Extra Large,Bardzo duży,
+Extra Small,Extra Small,
+Fail,Zawieść,
+Failed,Nieudane,
+Failed to create website,Nie udało się utworzyć witryny,
+Failed to install presets,Nie udało się zainstalować ustawień wstępnych,
+Failed to login,Nie udało się zalogować,
+Failed to setup company,Nie udało się skonfigurować firmy,
+Failed to setup defaults,Nie udało się skonfigurować ustawień domyślnych,
+Failed to setup post company fixtures,Nie udało się skonfigurować urządzeń firm post,
+Fax,Faks,
+Fee,Opłata,
+Fee Created,Opłata utworzona,
+Fee Creation Failed,Utworzenie opłaty nie powiodło się,
+Fee Creation Pending,Tworzenie opłat w toku,
+Fee Records Created - {0},Utworzono Records Fee - {0},
+Feedback,Informacja zwrotna,
+Fees,Opłaty,
+Female,Kobieta,
+Fetch Data,Pobierz dane,
+Fetch Subscription Updates,Pobierz aktualizacje subskrypcji,
+Fetch exploded BOM (including sub-assemblies),Pobierz rozbitą BOM (w tym podzespoły),
+Fetching records......,Pobieranie rekordów ......,
+Field Name,Nazwa pola,
+Fieldname,Nazwa pola,
+Fields,Pola,
+Fill the form and save it,Wypełnij formularz i zapisz,
+Filter Employees By (Optional),Filtruj pracowników według (opcjonalnie),
+"Filter Fields Row #{0}: Fieldname <b>{1}</b> must be of type ""Link"" or ""Table MultiSelect""",Filtruj pola Wiersz # {0}: Nazwa pola <b>{1}</b> musi być typu „Link” lub „Tabela MultiSelect”,
+Filter Total Zero Qty,Filtruj całkowitą liczbę zerową,
+Finance Book,Książka finansowa,
+Financial / accounting year.,Rok finansowy / księgowy.,
+Financial Services,Usługi finansowe,
+Financial Statements,Sprawozdania finansowe,
+Financial Year,Rok budżetowy,
+Finish,koniec,
+Finished Good,Skończony dobrze,
+Finished Good Item Code,Gotowy kod dobrego towaru,
+Finished Goods,Ukończone dobra,
+Finished Item {0} must be entered for Manufacture type entry,Zakończone Pozycja {0} musi być wprowadzony do wejścia typu Produkcja,
+Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Ilość gotowego produktu <b>{0}</b> i ilość <b>{1}</b> nie mogą się różnić,
+First Name,Imię,
+"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","System fiskalny jest obowiązkowy, uprzejmie ustal system podatkowy w firmie {0}",
+Fiscal Year,Rok podatkowy,
+Fiscal Year End Date should be one year after Fiscal Year Start Date,Data zakończenia roku obrachunkowego powinna wynosić jeden rok od daty rozpoczęcia roku obrachunkowego,
+Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Rok obrotowy Data rozpoczęcia i Data zakończenia roku obrotowego są już ustawione w roku podatkowym {0},
+Fiscal Year Start Date should be one year earlier than Fiscal Year End Date,Data rozpoczęcia roku podatkowego powinna być o rok wcześniejsza niż data zakończenia roku obrotowego,
+Fiscal Year {0} does not exist,Rok fiskalny {0} nie istnieje,
+Fiscal Year {0} is required,Rok fiskalny {0} jest wymagane,
+Fiscal Year {0} not found,Rok fiskalny {0} Nie znaleziono,
+Fixed Asset,Trwała własność,
+Fixed Asset Item must be a non-stock item.,Trwałego Rzecz musi być element non-stock.,
+Fixed Assets,Środki trwałe,
+Following Material Requests have been raised automatically based on Item's re-order level,Niniejszy materiał Wnioski zostały podniesione automatycznie na podstawie poziomu ponownego zamówienia elementu,
+Following accounts might be selected in GST Settings:,W ustawieniach GST można wybrać następujące konta:,
+Following course schedules were created,Utworzono harmonogramy kursów,
+Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Poniższy element {0} nie jest oznaczony jako element {1}. Możesz je włączyć jako element {1} z jego wzorca pozycji,
+Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,Następujące elementy {0} nie są oznaczone jako {1}. Możesz je włączyć jako element {1} z jego wzorca pozycji,
+Food,Żywność,
+"Food, Beverage & Tobacco","Żywność, Trunki i Tytoń",
+For,Dla,
+"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Dla pozycji &quot;Produkt Bundle&quot;, magazyn, nr seryjny i numer partii będą rozpatrywane z &quot;packing list&quot; tabeli. Jeśli magazynowe oraz Batch Nie są takie same dla wszystkich elementów Opakowanie do pozycji każdego &quot;produkt Bundle&quot;, wartości te mogą zostać wpisane do tabeli głównej pozycji, wartości zostaną skopiowane do &quot;packing list&quot; tabeli.",
+For Employee,Dla pracownika,
+For Quantity (Manufactured Qty) is mandatory,Do Ilość (Wyprodukowano kopie) są obowiązkowe,
+For Supplier,Dla dostawcy,
+For Warehouse,Dla magazynu,
+For Warehouse is required before Submit,Dla magazynu jest wymagane przed wysłaniem,
+"For an item {0}, quantity must be negative number",W przypadku elementu {0} ilość musi być liczbą ujemną,
+"For an item {0}, quantity must be positive number",W przypadku elementu {0} liczba musi być liczbą dodatnią,
+"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",W przypadku karty pracy {0} można dokonać tylko wpisu typu „Transfer materiałów do produkcji”,
+"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Do rzędu {0} w {1}. Aby dołączyć {2} w cenę towaru, wiersze {3} musi być włączone",
+For row {0}: Enter Planned Qty,Dla wiersza {0}: wpisz planowaną liczbę,
+"For {0}, only credit accounts can be linked against another debit entry","Dla {0}, tylko Kredytowane konta mogą być połączone z innym zapisem po stronie debetowej",
+"For {0}, only debit accounts can be linked against another credit entry","Dla {0}, tylko rachunki płatnicze mogą być połączone z innym wejściem kredytową",
+Forum Activity,Aktywność na forum,
+Free item code is not selected,Kod wolnego przedmiotu nie jest wybrany,
+Freight and Forwarding Charges,Koszty dostaw i przesyłek,
+Frequency,Częstotliwość,
+Friday,Piątek,
+From,Od,
+From Address 1,Od adresu 1,
+From Address 2,Od adresu 2,
+From Currency and To Currency cannot be same,Od Waluty i Do Waluty nie mogą być te same,
+From Date and To Date lie in different Fiscal Year,Od daty i daty są różne w danym roku obrotowym,
+From Date cannot be greater than To Date,Data od - nie może być późniejsza niż Data do,
+From Date must be before To Date,Data od musi być przed datą do,
+From Date should be within the Fiscal Year. Assuming From Date = {0},"""Data od"" powinna być w tym roku podatkowym. Przyjmując Datę od = {0}",
+From Date {0} cannot be after employee's relieving Date {1},Od daty {0} nie może być po zwolnieniu pracownika Data {1},
+From Date {0} cannot be before employee's joining Date {1},Od daty {0} nie może upłynąć data dołączenia pracownika {1},
+From Datetime,Od DateTime,
+From Delivery Note,Od dowodu dostawy,
+From Fiscal Year,Od roku obrotowego,
+From GSTIN,Z GSTIN,
+From Party Name,Od nazwy imprezy,
+From Pin Code,Z kodu PIN,
+From Place,Z miejsca,
+From Range has to be less than To Range,Od Zakres musi być mniejsza niż do zakresu,
+From State,Z państwa,
+From Time,Od czasu,
+From Time Should Be Less Than To Time,Od czasu powinno być mniej niż w czasie,
+From Time cannot be greater than To Time.,Od czasu nie może być większa niż do czasu.,
+"From a supplier under composition scheme, Exempt and Nil rated","Od dostawcy w ramach systemu składu, Zwolniony i Nil oceniono",
+From and To dates required,Daty Od i Do są wymagane,
+From date can not be less than employee's joining date,Od daty nie może być mniejsza niż data dołączenia pracownika,
+From value must be less than to value in row {0},"Wartość ""od"" musi być mniejsza niż wartość w rzędzie {0}",
+From {0} | {1} {2},Od {0} | {1} {2},
+Fuel Price,Cena paliwa,
+Fuel Qty,Ilość paliwa,
+Fulfillment,Spełnienie,
+Full,Pełny,
+Full Name,Imię i nazwisko,
+Full-time,Na cały etet,
+Fully Depreciated,pełni zamortyzowanych,
+Furnitures and Fixtures,Meble i wyposażenie,
+"Further accounts can be made under Groups, but entries can be made against non-Groups","Dalsze relacje mogą być wykonane w ramach grup, ale wpisy mogą być wykonane przed spoza grup",
+Further cost centers can be made under Groups but entries can be made against non-Groups,"Kolejne centra kosztów mogą być wykonane w ramach grup, ale wpisy mogą być wykonane przed spoza grup",
+Further nodes can be only created under 'Group' type nodes,"Kolejne powiązania mogą być tworzone tylko w powiązaniach typu ""grupa""",
+Future dates not allowed,Przyszłe daty są niedozwolone,
+GSTIN,GSTIN,
+GSTR3B-Form,Formularz GSTR3B,
+Gain/Loss on Asset Disposal,Zysk / Strata na Aktywów pozbywaniu,
+Gantt Chart,Wykres Gantta,
+Gantt chart of all tasks.,Wykres Gantta dla wszystkich zadań.,
+Gender,Płeć,
+General,Ogólne,
+General Ledger,Księga Główna,
+Generate Material Requests (MRP) and Work Orders.,Generuj zapotrzebowanie materiałowe (MRP) i zlecenia pracy.,
+Generate Secret,Generuj sekret,
+Get Details From Declaration,Uzyskaj szczegółowe informacje z deklaracji,
+Get Employees,Zdobądź pracowników,
+Get Invocies,Zdobądź Invocies,
+Get Invoices,Uzyskaj faktury,
+Get Invoices based on Filters,Uzyskaj faktury na podstawie filtrów,
+Get Items from BOM,Weź produkty z zestawienia materiałowego,
+Get Items from Healthcare Services,Pobierz przedmioty z usług opieki zdrowotnej,
+Get Items from Prescriptions,Zdobądź przedmioty z recept,
+Get Items from Product Bundle,Elementy z Bundle produktu,
+Get Suppliers,Dodaj dostawców,
+Get Suppliers By,Dodaj dostawców wg,
+Get Updates,Informuj o aktualizacjach,
+Get customers from,Zdobądź klientów,
+Get from Patient Encounter,Uzyskaj od Spotkania Pacjenta,
+Getting Started,Start,
+GitHub Sync ID,GitHub Sync ID,
+Global settings for all manufacturing processes.,Globalne ustawienia dla wszystkich procesów produkcyjnych.,
+Go to the Desktop and start using ERPNext,Przejdź do pulpitu i rozpocząć korzystanie ERPNext,
+GoCardless SEPA Mandate,Mandat SEPA bez karty,
+GoCardless payment gateway settings,Ustawienia bramy płatności bez płatności,
+Goal and Procedure,Cel i procedura,
+Goals cannot be empty,Cele nie mogą być puste,
+Goods In Transit,Towary w tranzycie,
+Goods Transferred,Przesyłane towary,
+Goods and Services Tax (GST India),Podatek od towarów i usług (GST India),
+Goods are already received against the outward entry {0},Towary są już otrzymane w stosunku do wpisu zewnętrznego {0},
+Government,Rząd,
+Grand Total,Suma Całkowita,
+Grant,Dotacja,
+Grant Application,Wniosek o dofinansowanie,
+Grant Leaves,Przydziel możliwe Nieobecności,
+Grant information.,Udziel informacji.,
+Grocery,Artykuły spożywcze,
+Gross Pay,Płaca brutto,
+Gross Profit,Zysk brutto,
+Gross Profit %,Zysk brutto%,
+Gross Profit / Loss,Zysk / Strata,
+Gross Purchase Amount,Zakup Kwota brutto,
+Gross Purchase Amount is mandatory,Zakup Kwota brutto jest obowiązkowe,
+Group by Account,Grupuj według konta,
+Group by Party,Grupa według partii,
+Group by Voucher,Grupuj według Podstawy księgowania,
+Group by Voucher (Consolidated),Group by Voucher (Consolidated),
+Group node warehouse is not allowed to select for transactions,"Magazyn węzeł Grupa nie jest dozwolone, aby wybrać dla transakcji",
+Group to Non-Group,Grupa do Non-Group,
+Group your students in batches,Grupa uczniowie w partiach,
+Groups,Grupy,
+Guardian1 Email ID,Identyfikator e-maila Guardian1,
+Guardian1 Mobile No,Guardian1 Komórka Nie,
+Guardian1 Name,Nazwa Guardian1,
+Guardian2 Email ID,Identyfikator e-mail Guardian2,
+Guardian2 Mobile No,Guardian2 Komórka Nie,
+Guardian2 Name,Nazwa Guardian2,
+Guest,Gość,
+HR Manager,Kierownik ds. Personalnych,
+HSN,HSN,
+HSN/SAC,HSN / SAC,
+Half Day,Pół Dnia,
+Half Day Date is mandatory,Data półdniowa jest obowiązkowa,
+Half Day Date should be between From Date and To Date,Pół Dzień Data powinna być pomiędzy Od Data i do tej pory,
+Half Day Date should be in between Work From Date and Work End Date,Data pół dnia powinna znajdować się pomiędzy datą pracy a datą zakończenia pracy,
+Half Yearly,Pół Roku,
+Half day date should be in between from date and to date,Data pół dnia powinna być pomiędzy datą i datą,
+Half-Yearly,Półroczny,
+Hardware,Sprzęt komputerowy,
+Head of Marketing and Sales,Kierownik marketingu i sprzedaży,
+Health Care,Opieka zdrowotna,
+Healthcare,Opieka zdrowotna,
+Healthcare (beta),Opieka zdrowotna (beta),
+Healthcare Practitioner,Praktyk opieki zdrowotnej,
+Healthcare Practitioner not available on {0},Pracownik służby zdrowia niedostępny na {0},
+Healthcare Practitioner {0} not available on {1},Pracownik służby zdrowia {0} nie jest dostępny w {1},
+Healthcare Service Unit,Jednostka opieki zdrowotnej,
+Healthcare Service Unit Tree,Drzewo usług opieki zdrowotnej,
+Healthcare Service Unit Type,Rodzaj usługi opieki zdrowotnej,
+Healthcare Services,Opieka zdrowotna,
+Healthcare Settings,Ustawienia opieki zdrowotnej,
+Hello,cześć,
+Help Results for,Pomoc Wyniki dla,
+High,Wysoki,
+High Sensitivity,Wysoka czułość,
+Hold,Trzymaj,
+Hold Invoice,Hold Invoice,
+Holiday,Święto,
+Holiday List,Lista Świąt,
+Hotel Rooms of type {0} are unavailable on {1},Pokoje hotelowe typu {0} są niedostępne w dniu {1},
+Hotels,Hotele,
+Hourly,Cogodzinny,
+Hours,godziny,
+House rent paid days overlapping with {0},Dni płatne za wynajem domu pokrywają się z {0},
+House rented dates required for exemption calculation,Daty wynajmu domu wymagane do obliczenia odstępstwa,
+House rented dates should be atleast 15 days apart,Terminy wynajmu domu powinny wynosić co najmniej 15 dni,
+How Pricing Rule is applied?,Jak reguła jest stosowana Wycena?,
+Hub Category,Kategoria koncentratora,
+Hub Sync ID,Identyfikator Hub Sync,
+Human Resource,Zasoby ludzkie,
+Human Resources,Kadry,
+IFSC Code,Kod IFSC,
+IGST Amount,Wielkość IGST,
+IP Address,Adres IP,
+ITC Available (whether in full op part),Dostępne ITC (czy w pełnej wersji),
+ITC Reversed,Odwrócono ITC,
+Identifying Decision Makers,Identyfikacja decydentów,
+"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)","Jeśli zaznaczona jest opcja automatycznego wyboru, klienci zostaną automatycznie połączeni z danym Programem lojalnościowym (przy zapisie)",
+"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Jeśli wiele Zasady ustalania cen nadal dominować, użytkownicy proszeni są o ustawienie Priorytet ręcznie rozwiązać konflikt.",
+"If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Jeśli wybrana zostanie reguła cenowa dla &quot;Stawka&quot;, nadpisze ona Cennik. Stawka za ustalanie stawek jest ostateczną stawką, więc nie należy stosować dodatkowej zniżki. W związku z tym w transakcjach takich jak zamówienie sprzedaży, zamówienie itp. Zostanie ono pobrane w polu &quot;stawka&quot;, a nie w polu &quot;cennik ofert&quot;.",
+"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.","Jeśli dwóch lub więcej Zasady ustalania cen na podstawie powyższych warunków, jest stosowana Priorytet. Priorytetem jest liczba z zakresu od 0 do 20, podczas gdy wartość domyślna wynosi zero (puste). Wyższa liczba oznacza, że będzie mieć pierwszeństwo, jeśli istnieje wiele przepisów dotyczących cen z samych warunkach.",
+"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.",W przypadku nielimitowanego wygaśnięcia punktów lojalnościowych czas trwania ważności jest pusty lub 0.,
+"If you have any questions, please get back to us.","Jeśli masz jakieś pytania, proszę wrócić do nas.",
+Ignore Existing Ordered Qty,Ignoruj istniejącą zamówioną ilość,
+Image,Obrazek,
+Image View,Widok obrazka,
+Import Data,Importuj dane,
+Import Day Book Data,Importuj dane książki dziennej,
+Import Log,Log operacji importu,
+Import Master Data,Importuj dane podstawowe,
+Import in Bulk,Masowego importu,
+Import of goods,Import towarów,
+Import of services,Import usług,
+Importing Items and UOMs,Importowanie elementów i UOM,
+Importing Parties and Addresses,Importowanie stron i adresów,
+In Maintenance,W naprawie,
+In Production,W produkcji,
+In Qty,W ilości,
+In Stock Qty,Ilość w magazynie,
+In Stock: ,W magazynie:,
+In Value,w polu Wartość,
+"In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent","W przypadku programu wielowarstwowego Klienci zostaną automatycznie przypisani do danego poziomu, zgodnie z wydatkami",
+Inactive,Nieaktywny,
+Include Default Book Entries,Dołącz domyślne wpisy książki,
+Include Exploded Items,Dołącz rozstrzelone przedmioty,
+Include POS Transactions,Uwzględnij transakcje POS,
+Include UOM,Dołącz UOM,
+Included in Gross Profit,Zawarte w zysku brutto,
+Income,Przychody,
+Income Account,Konto przychodów,
+Income Tax,Podatek dochodowy,
+Incoming,Przychodzące,
+Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Nieprawidłowa liczba zapisów w Księdze głównej. Być może wybrano niewłaściwe konto w transakcji.,
+Increment cannot be 0,Przyrost nie może być 0,
+Increment for Attribute {0} cannot be 0,Przyrost dla atrybutu {0} nie może być 0,
+Indirect Expenses,Wydatki pośrednie,
+Indirect Income,Przychody pośrednie,
+Individual,Indywidualny,
+Ineligible ITC,Niekwalifikowany ITC,
+Initiated,Zapoczątkowany,
+Inpatient Record,Zapis ambulatoryjny,
+Insert,Wstaw,
+Installation Note,Notka instalacyjna,
+Installation Note {0} has already been submitted,Notka instalacyjna {0} została już dodana,
+Installation date cannot be before delivery date for Item {0},Data instalacji nie może być wcześniejsza niż data dostawy dla pozycji {0},
+Installing presets,Instalowanie ustawień wstępnych,
+Institute Abbreviation,Instytut Skrót,
+Institute Name,Nazwa Instytutu,
+Instructor,Instruktor,
+Insufficient Stock,Niewystarczający zapas,
+Insurance Start date should be less than Insurance End date,Data rozpoczęcia ubezpieczenia powinna być mniejsza niż data zakończenia ubezpieczenia,
+Integrated Tax,Zintegrowany podatek,
+Inter-State Supplies,Dostawy międzypaństwowe,
+Interest Amount,Kwota procentowa,
+Interests,Zainteresowania,
+Intern,Stażysta,
+Internet Publishing,Wydawnictwa internetowe,
+Intra-State Supplies,Materiały wewnątrzpaństwowe,
+Introduction,Wprowadzenie,
+Invalid Attribute,Nieprawidłowy atrybut,
+Invalid Blanket Order for the selected Customer and Item,Nieprawidłowe zamówienie zbiorcze dla wybranego klienta i przedmiotu,
+Invalid Company for Inter Company Transaction.,Nieważna firma dla transakcji między przedsiębiorstwami.,
+Invalid GSTIN! A GSTIN must have 15 characters.,Nieprawidłowy GSTIN! GSTIN musi mieć 15 znaków.,
+Invalid GSTIN! First 2 digits of GSTIN should match with State number {0}.,Nieprawidłowy GSTIN! Pierwsze 2 cyfry GSTIN powinny pasować do numeru stanu {0}.,
+Invalid GSTIN! The input you've entered doesn't match the format of GSTIN.,Nieprawidłowy GSTIN! Wprowadzone dane nie pasują do formatu GSTIN.,
+Invalid Posting Time,Nieprawidłowy czas publikacji,
+Invalid attribute {0} {1},Nieprawidłowy atrybut {0} {1},
+Invalid quantity specified for item {0}. Quantity should be greater than 0.,Nieprawidłowa ilość określona dla elementu {0}. Ilość powinna być większa niż 0.,
+Invalid reference {0} {1},Nieprawidłowy odniesienia {0} {1},
+Invalid {0},Nieprawidłowy {0},
+Invalid {0} for Inter Company Transaction.,Nieprawidłowy {0} dla transakcji między przedsiębiorstwami.,
+Invalid {0}: {1},Nieprawidłowy {0}: {1},
+Inventory,Inwentarz,
+Investment Banking,Bankowość inwestycyjna,
+Investments,Inwestycje,
+Invoice,Faktura,
+Invoice Created,Utworzono fakturę,
+Invoice Discounting,Dyskontowanie faktury,
+Invoice Patient Registration,Rejestracja pacjenta faktury,
+Invoice Posting Date,Faktura Data zamieszczenia,
+Invoice Type,Typ faktury,
+Invoice already created for all billing hours,Faktura została już utworzona dla wszystkich godzin rozliczeniowych,
+Invoice can't be made for zero billing hour,Faktura nie może zostać wystawiona na zero godzin rozliczeniowych,
+Invoice {0} no longer exists,Faktura {0} już nie istnieje,
+Invoiced,Zafakturowane,
+Invoiced Amount,Kwota zafakturowana,
+Invoices,Faktury,
+Invoices for Costumers.,Faktury dla klientów.,
+Inward supplies from ISD,Dostawy wewnętrzne z ISD,
+Inward supplies liable to reverse charge (other than 1 & 2 above),Dostawy wewnętrzne podlegające zwrotowi (inne niż 1 i 2 powyżej),
+Is Active,Jest aktywny,
+Is Default,Jest domyślny,
+Is Existing Asset,Czy istniejącego środka trwałego,
+Is Frozen,Zamrożony,
+Is Group,Czy Grupa,
+Issue,Zdarzenie,
+Issue Material,Wydanie Materiał,
+Issued,Wydany,
+Issues,Zagadnienia,
+It is needed to fetch Item Details.,"Jest to niezbędne, aby pobrać szczegółowe dotyczące pozycji.",
+Item,Asortyment,
+Item 1,Pozycja 1,
+Item 2,Pozycja 2,
+Item 3,Pozycja 3,
+Item 4,Pozycja 4,
+Item 5,Pozycja 5,
+Item Cart,poz Koszyk,
+Item Code,Kod identyfikacyjny,
+Item Code cannot be changed for Serial No.,Kod przedmiotu nie może być zmieniony na podstawie numeru seryjnego,
+Item Code required at Row No {0},Wymagany jest kod elementu w wierszu nr {0},
+Item Description,Opis produktu,
+Item Group,Kategoria,
+Item Group Tree,Drzewo kategorii,
+Item Group not mentioned in item master for item {0},Pozycja Grupa nie wymienione w pozycji do pozycji mistrza {0},
+Item Name,Nazwa przedmiotu,
+Item Price added for {0} in Price List {1},Pozycja Cena dodany do {0} w Cenniku {1},
+"Item Price appears multiple times based on Price List, Supplier/Customer, Currency, Item, UOM, Qty and Dates.","Cena produktu pojawia się wiele razy w oparciu o Cennik, Dostawcę / Klienta, Walutę, Pozycję, UOM, Ilość i Daty.",
+Item Price updated for {0} in Price List {1},Pozycja Cena aktualizowana {0} w Cenniku {1},
+Item Row {0}: {1} {2} does not exist in above '{1}' table,Wiersz pozycji {0}: {1} {2} nie istnieje w powyższej tabeli &quot;{1}&quot;,
+Item Template,Szablon przedmiotu,
+Item Variant Settings,Ustawienia wariantu pozycji,
+Item Variant {0} already exists with same attributes,Pozycja Wersja {0} istnieje już z samymi atrybutami,
+Item Variants,Warianty artykuł,
+Item Variants updated,Zaktualizowano wariant produktu,
+Item has variants.,Pozycja ma warianty.,
+Item must be added using 'Get Items from Purchase Receipts' button,"Rzecz musi być dodane za ""elementy z zakupu wpływy"" przycisk",
+Item valuation rate is recalculated considering landed cost voucher amount,Jednostkowy wskaźnik wyceny przeliczone z uwzględnieniem kosztów ilość kupon wylądował,
+Item variant {0} exists with same attributes,Pozycja wariant {0} istnieje z samymi atrybutami,
+Item {0} does not exist,Element {0} nie istnieje,
+Item {0} does not exist in the system or has expired,Element {0} nie istnieje w systemie lub wygasł,
+Item {0} has already been returned,Element {0} został zwrócony,
+Item {0} has been disabled,Element {0} została wyłączona,
+Item {0} has reached its end of life on {1},Element {0} osiągnął kres przydatności {1},
+Item {0} ignored since it is not a stock item,"Element {0} jest ignorowany od momentu, kiedy nie ma go w magazynie",
+"Item {0} is a template, please select one of its variants","Element {0} jest szablon, należy wybrać jedną z jego odmian",
+Item {0} is cancelled,Element {0} jest anulowany,
+Item {0} is disabled,Element {0} jest wyłączony,
+Item {0} is not a stock Item,Element {0} nie jest w magazynie,
+Item {0} is not active or end of life has been reached,"Element {0} nie jest aktywny, lub osiągnął datę przydatności",
+Item {0} is not setup for Serial Nos. Check Item master,Element {0} nie jest ustawiony na nr seryjny. Sprawdź mastera tego elementu,
+Item {0} is not setup for Serial Nos. Column must be blank,Element {0} nie jest ustawiony na nr seryjny. Kolumny powinny być puste,
+Item {0} must be a Fixed Asset Item,Element {0} musi być trwałego przedmiotu,
+Item {0} must be a non-stock item,Element {0} musi być elementem non-stock,
+Item {0} must be a stock Item,Item {0} musi być dostępna w magazynie,
+Item {0} not found,Element {0} nie został znaleziony,
+Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Element {0} nie znajdują się w &quot;materiały dostarczane&quot; tabeli w Zamówieniu {1},
+Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Element {0}: Zamówione szt {1} nie może być mniejsza niż minimalna Ilość zamówień {2} (określonego w pkt).,
+Item: {0} does not exist in the system,Pozycja: {0} nie istnieje w systemie,
+Items,Produkty,
+Items Filter,Elementy Filtruj,
+Items and Pricing,Produkty i cennik,
+Items for Raw Material Request,Elementy do żądania surowca,
+Job Card,Karta pracy,
+Job Description,Opis stanowiska Pracy,
+Job Offer,Oferta pracy,
+Job card {0} created,Utworzono kartę zadania {0},
+Jobs,Oferty pracy,
+Join,łączyć,
+Journal Entries {0} are un-linked,Zapisy księgowe {0} nie są powiązane,
+Journal Entry,Zapis księgowy,
+Journal Entry {0} does not have account {1} or already matched against other voucher,Księgowanie {0} nie masz konta {1} lub już porównywane inne bon,
+Kanban Board,Kanban Board,
+Key Reports,Kluczowe raporty,
+LMS Activity,Aktywność LMS,
+Lab Test,Test laboratoryjny,
+Lab Test Report,Raport z testów laboratoryjnych,
+Lab Test Sample,Próbka do badań laboratoryjnych,
+Lab Test Template,Szablon testu laboratoryjnego,
+Lab Test UOM,Lab Test UOM,
+Lab Tests and Vital Signs,Testy laboratoryjne i Vital Signs,
+Lab result datetime cannot be before testing datetime,Data zestawienia wyników laboratorium nie może być wcześniejsza niż test datetime,
+Lab testing datetime cannot be before collection datetime,Data testowania laboratorium nie może być datą zbierania danych,
+Label,etykieta,
+Laboratory,Laboratorium,
+Language Name,Nazwa Język,
+Large,Duży,
+Last Communication,Ostatnia komunikacja,
+Last Communication Date,Ostatni dzień komunikacji,
+Last Name,Nazwisko,
+Last Order Amount,Kwota ostatniego zamówienia,
+Last Order Date,Data ostatniego zamówienia,
+Last Purchase Price,Ostatnia cena zakupu,
+Last Purchase Rate,Data Ostatniego Zakupu,
+Latest,Ostatnie,
+Latest price updated in all BOMs,Aktualna cena została zaktualizowana we wszystkich biuletynach,
+Lead,Potencjalny klient,
+Lead Count,Liczba potencjalnych klientów,
+Lead Owner,Właściciel Tropu,
+Lead Owner cannot be same as the Lead,Ołów Właściciel nie może być taka sama jak Lead,
+Lead Time Days,Czas realizacji (dni),
+Lead to Quotation,Trop do Wyceny,
+"Leads help you get business, add all your contacts and more as your leads","Przewody pomóc biznesu, dodać wszystkie kontakty i więcej jak swoich klientów",
+Learn,Samouczek,
+Leave Approval Notification,Powiadomienie o zmianie zatwierdzającego Nieobecność,
+Leave Blocked,Urlop Zablokowany,
+Leave Encashment,Zostawić Inkaso,
+Leave Management,Zarządzanie Nieobecnościami,
+Leave Status Notification,Powiadomienie o Statusie zgłoszonej Nieobecności,
+Leave Type,Typ urlopu,
+Leave Type is madatory,Typ Nieobecności jest polem wymaganym,
+Leave Type {0} cannot be allocated since it is leave without pay,"Typ Nieobecności {0} nie może zostać zaalokowany, ponieważ jest Urlopem Bezpłatnym",
+Leave Type {0} cannot be carry-forwarded,Typ Nieobecności {0} nie może zostać przeniesiony w przyszłość,
+Leave Type {0} is not encashable,Typ opuszczenia {0} nie podlega szyfrowaniu,
+Leave Without Pay,Urlop bezpłatny,
+Leave and Attendance,Nieobecności i Obecności,
+Leave application {0} already exists against the student {1},Pozostaw aplikację {0} już istnieje przeciwko uczniowi {1},
+"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Nieobecność nie może być przyznana przed {0}, a bilans nieobecności został już przeniesiony na przyszły wpis alokacyjny nieobecności {1}",
+"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Zostaw nie mogą być stosowane / anulowana przed {0}, a bilans urlopu zostało już przeniesionych przekazywane w przyszłości rekordu alokacji urlopu {1}",
+Leave of type {0} cannot be longer than {1},Urlop typu {0} nie może być dłuższy niż {1},
+Leaves,Odchodzi,
+Leaves Allocated Successfully for {0},Nieobecności Przedzielono z Powodzeniem dla {0},
+Leaves has been granted sucessfully,Nieobecności zostały przyznane z powodzeniem,
+Leaves must be allocated in multiples of 0.5,"Urlop musi być zdefiniowany jako wielokrotność liczby ""0.5""",
+Leaves per Year,Nieobecności w Roku,
+Ledger,Rejestr,
+Legal,Legalnie,
+Legal Expenses,Wydatki na obsługę prawną,
+Letter Head,Nagłówek,
+Letter Heads for print templates.,Nagłówki dla szablonów druku,
+Level,Poziom,
+Liability,Zobowiązania,
+License,Licencja,
+Lifecycle,Koło życia,
+Limit,Limit,
+Limit Crossed,Limit Crossed,
+Link to Material Request,Link do żądania materiałowego,
+List of all share transactions,Lista wszystkich transakcji akcji,
+List of available Shareholders with folio numbers,Lista dostępnych Akcjonariuszy z numerami folio,
+Loading Payment System,Ładowanie systemu płatności,
+Loan,Pożyczka,
+Loan Amount cannot exceed Maximum Loan Amount of {0},Kwota kredytu nie może przekroczyć maksymalna kwota kredytu o {0},
+Loan Application,Podanie o pożyczkę,
+Loan Management,Zarządzanie kredytem,
+Loan Repayment,Spłata pożyczki,
+Loan Start Date and Loan Period are mandatory to save the Invoice Discounting,"Data rozpoczęcia pożyczki i okres pożyczki są obowiązkowe, aby zapisać dyskontowanie faktury",
+Loans (Liabilities),Kredyty (zobowiązania),
+Loans and Advances (Assets),Pożyczki i zaliczki (aktywa),
+Local,Lokalne,
+Log,Log,
+Logs for maintaining sms delivery status,Logi do utrzymania sms stan przesyłki,
+Lost,Straty,
+Lost Reasons,Przegrane przyczyny,
+Low,Niski,
+Low Sensitivity,Mała czułość,
+Lower Income,Niższy przychód,
+Loyalty Amount,Kwota lojalności,
+Loyalty Point Entry,Punkt lojalnościowy,
+Loyalty Points,Punkty lojalnościowe,
+"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Punkty lojalnościowe będą obliczane na podstawie zużytego (za pomocą faktury sprzedaży), na podstawie wspomnianego współczynnika zbierania.",
+Loyalty Points: {0},Punkty lojalnościowe: {0},
+Loyalty Program,Program lojalnościowy,
+Main,Główny,
+Maintenance,Konserwacja,
+Maintenance Log,Dziennik konserwacji,
+Maintenance Manager,Menager Konserwacji,
+Maintenance Schedule,Plan Konserwacji,
+Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Plan Konserwacji nie jest generowany dla wszystkich przedmiotów. Proszę naciśnij ""generuj plan""",
+Maintenance Schedule {0} exists against {1},Harmonogram konserwacji {0} istnieje przeciwko {1},
+Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Plan Konserwacji {0} musi być anulowany przed usunięciem tego zamówienia,
+Maintenance Status has to be Cancelled or Completed to Submit,Stan konserwacji musi zostać anulowany lub uzupełniony do przesłania,
+Maintenance User,Użytkownik Konserwacji,
+Maintenance Visit,Wizyta Konserwacji,
+Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Wizyta Konserwacji {0} musi być anulowana przed usunięciem nakazu sprzedaży,
+Maintenance start date can not be before delivery date for Serial No {0},Początek daty konserwacji nie może być wcześniejszy od daty numeru seryjnego {0},
+Make,Stwórz,
+Make Payment,Dokonać płatności,
+Make project from a template.,Utwórz projekt z szablonu.,
+Making Stock Entries,Dokonywanie stockowe Wpisy,
+Male,Mężczyzna,
+Manage Customer Group Tree.,Zarządzaj drzewem grupy klientów,
+Manage Sales Partners.,Zarządzaj Partnerami Sprzedaży.,
+Manage Sales Person Tree.,Zarządzaj Drzewem Sprzedawców,
+Manage Territory Tree.,Zarządzaj drzewem terytorium,
+Manage your orders,Zarządzanie zamówień,
+Management,Zarząd,
+Manager,Menager,
+Managing Projects,Zarządzanie projektami,
+Managing Subcontracting,Zarządzanie Podwykonawstwo,
+Mandatory,Obowiązkowe,
+Mandatory field - Academic Year,Pole obowiązkowe - Rok akademicki,
+Mandatory field - Get Students From,Pole obowiązkowe - pobierz uczniów,
+Mandatory field - Program,Pole obowiązkowe - program,
+Manufacture,Produkcja,
+Manufacturer,Producent,
+Manufacturer Part Number,Numer katalogowy producenta,
+Manufacturing,Produkcja,
+Manufacturing Quantity is mandatory,Ilość wyprodukowanych jest obowiązkowa,
+Mapping,Mapowanie,
+Mapping Type,Typ odwzorowania,
+Mark Absent,Oznacz Nieobecna,
+Mark Attendance,Oznaczaj Uczestnictwo,
+Mark Half Day,Oznacz pół dnia,
+Mark Present,Mark Present,
+Marketing,Marketing,
+Marketing Expenses,Wydatki marketingowe,
+Marketplace,Rynek,
+Marketplace Error,Błąd na rynku,
+Masters,Magistrowie,
+Match Payments with Invoices,Płatności mecz fakturami,
+Match non-linked Invoices and Payments.,Łączenie faktur z płatnościami,
+Material,Materiał,
+Material Consumption,Zużycie materiału,
+Material Consumption is not set in Manufacturing Settings.,Zużycie materiału nie jest ustawione w ustawieniach produkcyjnych.,
+Material Receipt,Przyjęcie materiałów,
+Material Request,Zamówienie produktu,
+Material Request Date,Materiał Zapytanie Data,
+Material Request No,Zamówienie produktu nr,
+"Material Request not created, as quantity for Raw Materials already available.","Nie utworzono wniosku o materiał, jako ilość dostępnych surowców.",
+Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Zamówienie produktu o maksymalnej ilości {0} może być zrealizowane dla przedmiotu {1} w zamówieniu {2},
+Material Request to Purchase Order,Twoje zamówienie jest w realizacji,
+Material Request {0} is cancelled or stopped,Zamówienie produktu {0} jest anulowane lub wstrzymane,
+Material Request {0} submitted.,Wysłano żądanie materiałowe {0}.,
+Material Transfer,Transfer materiałów,
+Material Transferred,Przeniesiony materiał,
+Material to Supplier,Materiał do dostawcy,
+Max Exemption Amount cannot be greater than maximum exemption amount {0} of Tax Exemption Category {1},Maksymalna kwota zwolnienia nie może być większa niż maksymalna kwota zwolnienia {0} kategorii zwolnienia podatkowego {1},
+Max benefits should be greater than zero to dispense benefits,Maksymalne korzyści powinny być większe niż zero w celu rozłożenia korzyści,
+Max discount allowed for item: {0} is {1}%,Maksymalna zniżka pozwoliło na pozycji: {0} jest {1}%,
+Max: {0},Max: {0},
+Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Maksymalne próbki - {0} mogą zostać zachowane dla Batch {1} i Item {2}.,
+Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maksymalne próbki - {0} zostały już zachowane dla partii {1} i pozycji {2} w partii {3}.,
+Maximum amount eligible for the component {0} exceeds {1},Maksymalna kwota kwalifikująca się do komponentu {0} przekracza {1},
+Maximum benefit amount of component {0} exceeds {1},Maksymalna kwota świadczenia komponentu {0} przekracza {1},
+Maximum benefit amount of employee {0} exceeds {1},Maksymalna kwota świadczenia pracownika {0} przekracza {1},
+Maximum discount for Item {0} is {1}%,Maksymalna zniżka dla pozycji {0} to {1}%,
+Maximum leave allowed in the leave type {0} is {1},Maksymalny dozwolony urlop w typie urlopu {0} to {1},
+Medical,Medyczny,
+Medical Code,Kodeks medyczny,
+Medical Code Standard,Standardowy kod medyczny,
+Medical Department,Wydział Lekarski,
+Medical Record,Historia choroby,
+Medium,Średni,
+Meeting,Spotkanie,
+Member Activity,Aktywność użytkownika,
+Member ID,ID Użytkownika,
+Member Name,Nazwa członka,
+Member information.,Informacje o członkach.,
+Membership,Członkostwo,
+Membership Details,Dane dotyczące członkostwa,
+Membership ID,Identyfikator członkostwa,
+Membership Type,typ członkostwa,
+Memebership Details,Szczegóły Memebership,
+Memebership Type Details,Szczegóły typu memebership,
+Merge,Łączyć,
+Merge Account,Połącz konto,
+Merge with Existing Account,Scal z istniejącym kontem,
+"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Połączenie jest możliwe tylko wtedy, gdy następujące właściwości są takie same w obu płyt. Czy Grupa Root Typ, Firma",
+Message Examples,Przykłady wiadomości,
+Message Sent,Wiadomość wysłana,
+Method,Metoda,
+Middle Income,Średni dochód,
+Middle Name,Drugie imię,
+Middle Name (Optional),Drugie imię (opcjonalnie),
+Min Amt can not be greater than Max Amt,Min Amt nie może być większy niż Max Amt,
+Min Qty can not be greater than Max Qty,Minimalna ilość nie może być większa niż maksymalna ilość,
+Minimum Lead Age (Days),Minimalny wiek ołowiu (dni),
+Miscellaneous Expenses,Pozostałe drobne wydatki,
+Missing Currency Exchange Rates for {0},Brakujące Wymiana walut stawki dla {0},
+Missing email template for dispatch. Please set one in Delivery Settings.,Brakujący szablon wiadomości e-mail do wysyłki. Ustaw jeden w Ustawieniach dostawy.,
+"Missing value for Password, API Key or Shopify URL","Brakująca wartość hasła, klucza API lub Shopify URL",
+Mode of Payment,Sposób płatności,
+Mode of Payments,Tryb płatności,
+Mode of Transport,Tryb transportu,
+Mode of Transportation,Środek transportu,
+Mode of payment is required to make a payment,"Sposób płatności jest wymagane, aby dokonać płatności",
+Model,Model,
+Moderate Sensitivity,Średnia czułość,
+Monday,Poniedziałek,
+Monthly,Miesięcznie,
+Monthly Distribution,Miesięczny Dystrybucja,
+Monthly Repayment Amount cannot be greater than Loan Amount,Miesięczna kwota spłaty nie może być większa niż Kwota kredytu,
+More,Więcej,
+More Information,Więcej informacji,
+More than one selection for {0} not allowed,Więcej niż jeden wybór dla {0} jest niedozwolony,
+More...,Jeszcze...,
+Motion Picture & Video,Ruchomy Obraz i Video,
+Move,ruch,
+Move Item,Move Item,
+Multi Currency,Wielowalutowy,
+Multiple Item prices.,Wiele cen przedmiotu.,
+Multiple Loyalty Program found for the Customer. Please select manually.,Znaleziono wiele programów lojalnościowych dla klienta. Wybierz ręcznie.,
+"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}",Wiele Zasad Cen istnieje w tych samych kryteriach proszę rozwiązywania konflikty poprzez przypisanie priorytetu. Zasady Cen: {0},
+Multiple Variants,Wiele wariantów,
+Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Wiele lat podatkowych istnieją na dzień {0}. Proszę ustawić firmy w roku finansowym,
+Music,Muzyka,
+My Account,Moje Konto,
+Name error: {0},Błąd Nazwa: {0},
+Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Nazwa nowego konta. Uwaga: Proszę nie tworzyć konta dla odbiorców i dostawców,
+Name or Email is mandatory,Imię lub E-mail jest obowiązkowe,
+Nature Of Supplies,Natura dostaw,
+Navigating,Nawigacja,
+Needs Analysis,Analiza potrzeb,
+Negative Quantity is not allowed,Ilość nie może być wyrażana na minusie,
+Negative Valuation Rate is not allowed,Błąd Szacowania Wartość nie jest dozwolona,
+Negotiation/Review,Negocjacje / przegląd,
+Net Asset value as on,Wartość aktywów netto na,
+Net Cash from Financing,Przepływy pieniężne netto z finansowania,
+Net Cash from Investing,Przepływy pieniężne netto z inwestycji,
+Net Cash from Operations,Środki pieniężne netto z działalności operacyjnej,
+Net Change in Accounts Payable,Zmiana netto stanu zobowiązań,
+Net Change in Accounts Receivable,Zmiana netto stanu należności,
+Net Change in Cash,Zmiana netto stanu środków pieniężnych,
+Net Change in Equity,Zmiana netto w kapitale własnym,
+Net Change in Fixed Asset,Zmiana netto stanu trwałego,
+Net Change in Inventory,Zmiana netto stanu zapasów,
+Net ITC Available(A) - (B),Net ITC Available (A) - (B),
+Net Pay,Stawka Netto,
+Net Pay cannot be less than 0,Wynagrodzenie netto nie może być mniejsza niż 0,
+Net Profit,Zysk netto,
+Net Salary Amount,Kwota wynagrodzenia netto,
+Net Total,Łączna wartość netto,
+Net pay cannot be negative,Stawka Netto nie może być na minusie,
+New Account Name,Nowa nazwa konta,
+New Address,Nowy adres,
+New BOM,Nowe zestawienie materiałowe,
+New Batch ID (Optional),Nowy identyfikator partii (opcjonalnie),
+New Batch Qty,Nowa partia,
+New Company,Nowa firma,
+New Cost Center Name,Nazwa nowego Centrum Kosztów,
+New Customer Revenue,Nowy Przychody klienta,
+New Customers,Nowi Klienci,
+New Department,Nowy dział,
+New Employee,Nowy pracownik,
+New Location,Nowa lokalizacja,
+New Quality Procedure,Nowa procedura jakości,
+New Sales Invoice,Nowa faktura sprzedaży,
+New Sales Person Name,Nazwa nowej osoby Sprzedaży,
+New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Nowy nr seryjny nie może mieć Magazynu. Magazyn musi być ustawiona przez Zasoby lub  na podstawie Paragonu Zakupu,
+New Warehouse Name,Nowy magazyn Nazwa,
+New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Nowy limit kredytowy wynosi poniżej aktualnej kwoty należności dla klienta. Limit kredytowy musi być conajmniej {0},
+New task,Nowe zadanie,
+New {0} pricing rules are created,Utworzono nowe {0} reguły cenowe,
+Newsletters,Biuletyny,
+Newspaper Publishers,Wydawcy gazet,
+Next,Dalej,
+Next Contact By cannot be same as the Lead Email Address,Następnie Kontakt By nie może być taki sam jak adres e-mail Wiodącego,
+Next Contact Date cannot be in the past,Następnie Kontakt Data nie może być w przeszłości,
+Next Steps,Następne kroki,
+No Action,Bez akcji,
+No Customers yet!,Brak klientów!,
+No Data,Brak danych,
+No Delivery Note selected for Customer {},Nie wybrano uwagi dostawy dla klienta {},
+No Employee Found,Nie znaleziono pracownika,
+No Item with Barcode {0},Nie istnieje Przedmiot o kodzie kreskowym {0},
+No Item with Serial No {0},Brak przedmiotu o podanym numerze seryjnym {0},
+No Items available for transfer,Brak przedmiotów do przeniesienia,
+No Items selected for transfer,Nie wybrano pozycji do przeniesienia,
+No Items to pack,Brak Przedmiotów do pakowania,
+No Items with Bill of Materials to Manufacture,Brak przedmioty z Bill of Materials do produkcji,
+No Items with Bill of Materials.,Brak przedmiotów z zestawieniem materiałów.,
+No Permission,Brak uprawnień,
+No Remarks,Brak uwag,
+No Result to submit,Brak wyniku,
+No Salary Structure assigned for Employee {0} on given date {1},Brak struktury wynagrodzenia dla pracownika {0} w danym dniu {1},
+No Staffing Plans found for this Designation,Nie znaleziono planów zatrudnienia dla tego oznaczenia,
+No Student Groups created.,Brak grup studenckich utworzony.,
+No Students in,Brak uczniów w Poznaniu,
+No Tax Withholding data found for the current Fiscal Year.,Nie znaleziono danych potrącenia podatku dla bieżącego roku obrotowego.,
+No Work Orders created,Nie utworzono zleceń pracy,
+No accounting entries for the following warehouses,Brak zapisów księgowych dla następujących magazynów,
+No active or default Salary Structure found for employee {0} for the given dates,Brak aktywnego czy ustawiona Wynagrodzenie Struktura znalezionych dla pracownika {0} dla podanych dat,
+No contacts with email IDs found.,Nie znaleziono kontaktów z identyfikatorami e-mail.,
+No data for this period,Brak danych dla tego okresu,
+No description given,Brak opisu,
+No employees for the mentioned criteria,Brak pracowników dla wymienionych kryteriów,
+No gain or loss in the exchange rate,Brak zysków lub strat w kursie wymiany,
+No items listed,Brak elementów na liście,
+No items to be received are overdue,Żadne przedmioty do odbioru nie są spóźnione,
+No material request created,Nie utworzono żadnego żadnego materialnego wniosku,
+No more updates,Brak więcej aktualizacji,
+No of Interactions,Liczba interakcji,
+No of Shares,Liczba akcji,
+No pending Material Requests found to link for the given items.,Nie znaleziono oczekujĘ ... cych żĘ ... danych żĘ ... danych w celu połĘ ... czenia dla podanych elementów.,
+No products found,Nie znaleziono produktów,
+No products found.,Nie znaleziono produktów.,
+No record found,Nie znaleziono wyników,
+No records found in the Invoice table,Nie znaleziono w tabeli faktury rekordy,
+No records found in the Payment table,Nie znaleziono rekordów w tabeli płatności,
+No replies from,Brak odpowiedzi ze strony,
+No salary slip found to submit for the above selected criteria OR salary slip already submitted,Nie znaleziono pokwitowania wypłaty za wyżej wymienione kryteria LUB wniosek o wypłatę wynagrodzenia już przesłano,
+No tasks,Brak zadań,
+No time sheets,Brak karty czasu,
+No values,Brak wartości,
+No {0} found for Inter Company Transactions.,"Nie znaleziono rekordów ""{0}"" dla transakcji między spółkami.",
+Non GST Inward Supplies,Non GST Inward Supplies,
+Non Profit,Brak Zysków,
+Non Profit (beta),Non Profit (beta),
+Non-GST outward supplies,Dostawy zewnętrzne spoza GST,
+Non-Group to Group,Dla grupy do grupy,
+None,Żaden,
+None of the items have any change in quantity or value.,Żaden z elementów ma żadnych zmian w ilości lub wartości.,
+Nos,Numery,
+Not Available,Niedostępny,
+Not Marked,nieoznaczone,
+Not Paid and Not Delivered,Nie Płatny i nie Dostarczany,
+Not Permitted,Niedozwolone,
+Not Started,Nie Rozpoczęte,
+Not active,Nieaktywny,
+Not allow to set alternative item for the item {0},Nie zezwalaj na ustawienie pozycji alternatywnej dla pozycji {0},
+Not allowed to update stock transactions older than {0},Niedozwolona jest modyfikacja transakcji zapasów starszych niż {0},
+Not authorized to edit frozen Account {0},Brak autoryzacji do edycji zamrożonego Konta {0},
+Not authroized since {0} exceeds limits,Brak autoryzacji od {0} przekroczono granice,
+Not permitted for {0},Nie dopuszczony do {0},
+"Not permitted, configure Lab Test Template as required","Niedozwolone, w razie potrzeby skonfiguruj szablon testu laboratorium",
+Not permitted. Please disable the Service Unit Type,Nie dozwolone. Wyłącz opcję Service Unit Type,
+Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Uwaga: Ze względu / Data odniesienia przekracza dozwolony dzień kredytowej klienta przez {0} dni (s),
+Note: Item {0} entered multiple times,Uwaga: Element {0} wpisano kilka razy,
+Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Uwaga: Płatność nie zostanie utworzona, gdyż nie określono konta 'Gotówka lub Bank'",
+Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Uwaga: System nie sprawdza nad-dostawy oraz nadmiernej rezerwacji dla pozycji {0} jej wartość lub kwota wynosi 0,
+Note: There is not enough leave balance for Leave Type {0},Uwaga: Nie ma wystarczającej ilości urlopu aby ustalić typ zwolnienia {0},
+Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Informacja: To Centrum Kosztów jest grupą. Nie mogę wykonać operacji rachunkowych na grupach.,
+Note: {0},Uwaga: {0},
+Notes,Notatki,
+Nothing is included in gross,Nic nie jest wliczone w brutto,
+Nothing more to show.,Nic więcej do pokazania.,
+Nothing to change,Nic do zmiany,
+Notice Period,Okres wypowiedzenia,
+Notify Customers via Email,Powiadom klientów przez e-mail,
+Number,Numer,
+Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Ilość amortyzacją Zarezerwowane nie może być większa od ogólnej liczby amortyzacją,
+Number of Interaction,Liczba interakcji,
+Number of Order,Numer zlecenia,
+"Number of new Account, it will be included in the account name as a prefix","Numer nowego Konta, zostanie dodany do nazwy konta jako prefiks",
+"Number of new Cost Center, it will be included in the cost center name as a prefix","Numer nowego miejsca powstawania kosztów, zostanie wprowadzony do nazwy miejsca powstawania kosztów jako prefiks",
+Number of root accounts cannot be less than 4,Liczba kont root nie może być mniejsza niż 4,
+Odometer,Drogomierz,
+Office Equipments,Urządzenie Biura,
+Office Maintenance Expenses,Wydatki na obsługę biura,
+Office Rent,Wydatki na wynajem,
+On Hold,W oczekiwaniu,
+On Net Total,Na podstawie Kwoty Netto,
+One customer can be part of only single Loyalty Program.,Jeden klient może być częścią tylko jednego Programu lojalnościowego.,
+Online Auctions,Aukcje online,
+Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Pozostawić tylko Aplikacje ze statusem „Approved” i „Odrzucone” mogą być składane,
+"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",W poniższej tabeli zostanie wybrana tylko osoba ubiegająca się o przyjęcie ze statusem &quot;Zatwierdzona&quot;.,
+Only users with {0} role can register on Marketplace,Tylko użytkownicy z rolą {0} mogą rejestrować się w usłudze Marketplace,
+Open BOM {0},Otwarte BOM {0},
+Open Item {0},Pozycja otwarta {0},
+Open Notifications,Otwarte Powiadomienia,
+Open Orders,Otwarte zlecenia,
+Open a new ticket,Otwórz nowy bilet,
+Opening,Otwarcie,
+Opening (Cr),Otwarcie (Cr),
+Opening (Dr),Otwarcie (Dr),
+Opening Accounting Balance,Stan z bilansu otwarcia,
+Opening Accumulated Depreciation,Otwarcie Skumulowana amortyzacja,
+Opening Accumulated Depreciation must be less than equal to {0},Otwarcie Skumulowana amortyzacja powinna być mniejsza niż równa {0},
+Opening Balance,Bilans otwarcia,
+Opening Balance Equity,Bilans otwarcia Kapitału własnego,
+Opening Date and Closing Date should be within same Fiscal Year,Otwarcie Data i termin powinien być w obrębie samego roku podatkowego,
+Opening Date should be before Closing Date,Data otwarcia powinien być przed Dniem Zamknięcia,
+Opening Entry Journal,Otwarcie dziennika wejścia,
+Opening Invoice Creation Tool,Otwieranie narzędzia tworzenia faktury,
+Opening Invoice Item,Otwieranie faktury,
+Opening Invoices,Otwieranie faktur,
+Opening Invoices Summary,Otwieranie podsumowań faktur,
+Opening Qty,Ilość otwarcia,
+Opening Stock,Otwarcie Zdjęcie,
+Opening Stock Balance,Saldo otwierające zapasy,
+Opening Value,Wartość otwarcia,
+Opening {0} Invoice created,Otworzono fakturę {0},
+Operation,Operacja,
+Operation Time must be greater than 0 for Operation {0},Czas działania musi być większy niż 0 do operacji {0},
+"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Operacja {0} dłużej niż wszelkie dostępne w godzinach pracy stacji roboczej {1}, rozbić na kilka operacji operacji",
+Operations,Działania,
+Operations cannot be left blank,Operacje nie może być puste,
+Opp Count,Opp Count,
+Opp/Lead %,Opp / ołów%,
+Opportunities,Możliwości,
+Opportunities by lead source,Możliwości według źródła ołowiu,
+Opportunity,Oferta,
+Opportunity Amount,Kwota możliwości,
+Optional Holiday List not set for leave period {0},Opcjonalna lista dni świątecznych nie jest ustawiona dla okresu urlopu {0},
+"Optional. Sets company's default currency, if not specified.","Opcjonalny. Ustawia domyślną walutę firmy, jeśli nie podano.",
+Optional. This setting will be used to filter in various transactions.,Opcjonalne. Te Ustawienie będzie użyte w filtrze dla różnych transacji.,
+Options,Opcje,
+Order Count,Liczba zamówień,
+Order Entry,Wprowadzanie zamówień,
+Order Value,Wartość zamówienia,
+Order rescheduled for sync,Zamów zmianę terminu do synchronizacji,
+Order/Quot %,Zamówienie / kwota%,
+Ordered,Zamówione,
+Ordered Qty,Ilość Zamówiona,
+Orders,Zamówienia,
+Orders released for production.,Zamówienia puszczone do produkcji.,
+Organization,Organizacja,
+Organization Name,Nazwa organizacji,
+Other,Inne,
+Other Reports,Inne raporty,
+"Other outward supplies(Nil rated,Exempted)","Inne dostawy zewnętrzne (bez oceny, zwolnione)",
+Others,Inni,
+Out Qty,Brak Ilości,
+Out Value,Brak Wartości,
+Out of Order,Nieczynny,
+Outgoing,Wychodzący,
+Outstanding,Wybitny,
+Outstanding Amount,Zaległa Ilość,
+Outstanding Amt,Zaległa wartość,
+Outstanding Cheques and Deposits to clear,"Wybitni Czeki i depozytów, aby usunąć",
+Outstanding for {0} cannot be less than zero ({1}),Zaległość za {0} nie może być mniejsza niż ({1}),
+Outward taxable supplies(zero rated),Dostaw podlegających opodatkowaniu zewnętrznemu (zero punktów),
+Overdue,Zaległy,
+Overlap in scoring between {0} and {1},Pokrywaj się w punktacji pomiędzy {0} a {1},
+Overlapping conditions found between:,Nakładające warunki pomiędzy:,
+Owner,Właściciel,
+PAN,Stały numer konta (PAN),
+POS,POS,
+POS Profile,POS profilu,
+POS Profile is required to use Point-of-Sale,Profil POS jest wymagany do korzystania z Point-of-Sale,
+POS Profile required to make POS Entry,Profil POS wymagany do tworzenia wpisu z POS,
+POS Settings,Ustawienia POS,
+Packed quantity must equal quantity for Item {0} in row {1},Wartość spakowana musi równać się ilości dla przedmiotu {0} w rzędzie {1},
+Packing Slip,List przewozowy,
+Packing Slip(s) cancelled,List(y) przewozowe anulowane,
+Paid,Zapłacono,
+Paid Amount,Zapłacona kwota,
+Paid Amount cannot be greater than total negative outstanding amount {0},Wpłaconej kwoty nie może być większa od całkowitej ujemnej kwoty należności {0},
+Paid amount + Write Off Amount can not be greater than Grand Total,Wartość zapłaty + Wartość odliczenia nie może być większa niż Cała Kwota,
+Paid and Not Delivered,Płatny i niedostarczone,
+Parameter,Parametr,
+Parent Item {0} must not be a Stock Item,Dominująca pozycja {0} nie może być pozycja Zdjęcie,
+Parents Teacher Meeting Attendance,Spotkanie wychowawców rodziców,
+Part-time,Niepełnoetatowy,
+Partially Depreciated,częściowo Zamortyzowany,
+Partially Received,Częściowo odebrane,
+Party,Grupa,
+Party Name,Nazwa Party,
+Party Type,Typ grupy,
+Party Type and Party is mandatory for {0} account,Typ strony i strona są obowiązkowe dla konta {0},
+Party Type is mandatory,Rodzaj Partia jest obowiązkowe,
+Party is mandatory,Partia jest obowiązkowe,
+Password,Hasło,
+Password policy for Salary Slips is not set,Polityka haseł dla poświadczeń wynagrodzenia nie jest ustawiona,
+Past Due Date,Minione terminy,
+Patient,Cierpliwy,
+Patient Appointment,Powtarzanie Pacjenta,
+Patient Encounter,Spotkanie z pacjentem,
+Patient not found,Nie znaleziono pacjenta,
+Pay Remaining,Zapłać pozostałe,
+Pay {0} {1},Zapłać {0} {1},
+Payable,Płatność,
+Payable Account,Konto płatności,
+Payable Amount,Kwota do zapłaty,
+Payment,Płatność,
+Payment Cancelled. Please check your GoCardless Account for more details,"Płatność anulowana. Sprawdź swoje konto bez karty, aby uzyskać więcej informacji",
+Payment Confirmation,Potwierdzenie płatności,
+Payment Date,Data płatności,
+Payment Days,Dni płatności,
+Payment Document,Płatność Dokument,
+Payment Due Date,Termin płatności,
+Payment Entries {0} are un-linked,Wpisy płatności {0} są un-linked,
+Payment Entry,Płatność,
+Payment Entry already exists,Zapis takiej Płatności już istnieje,
+Payment Entry has been modified after you pulled it. Please pull it again.,Wpis płatności został zmodyfikowany po ściągnięciu. Proszę ściągnąć ponownie.,
+Payment Entry is already created,Zapis takiej Płatności już został utworzony,
+Payment Failed. Please check your GoCardless Account for more details,"Płatność nie powiodła się. Sprawdź swoje konto bez karty, aby uzyskać więcej informacji",
+Payment Gateway,Bramki płatności,
+"Payment Gateway Account not created, please create one manually.","Payment Gateway konta nie jest tworzony, należy utworzyć ręcznie.",
+Payment Gateway Name,Nazwa bramki płatności,
+Payment Mode,Tryb Płatności,
+Payment Receipt Note,Otrzymanie płatności Uwaga,
+Payment Request,Żądanie zapłaty,
+Payment Request for {0},Prośba o płatność za {0},
+Payment Tems,Tematyka płatności,
+Payment Term,Termin płatności,
+Payment Terms,Zasady płatności,
+Payment Terms Template,Szablon warunków płatności,
+Payment Terms based on conditions,Warunki płatności oparte na warunkach,
+Payment Type,Typ płatności,
+"Payment Type must be one of Receive, Pay and Internal Transfer",Typ płatności musi być jednym z Odbierz Pay and przelew wewnętrzny,
+Payment against {0} {1} cannot be greater than Outstanding Amount {2},Płatność przed {0} {1} nie może być większa niż kwota kredytu pozostała {2},
+Payment of {0} from {1} to {2},Płatność {0} od {1} do {2},
+Payment request {0} created,Żądanie zapłaty {0} zostało utworzone,
+Payments,Płatności,
+Payroll,Lista płac,
+Payroll Number,Numer listy płac,
+Payroll Payable,Płace Płatne,
+Payslip,Odcinek wypłaty,
+Pending Activities,Oczekujące Inne,
+Pending Amount,Kwota Oczekiwana,
+Pending Leaves,Oczekujące Nieobecności,
+Pending Qty,Oczekuje szt,
+Pending Quantity,Ilość oczekująca,
+Pending Review,Czekający na rewizję,
+Pending activities for today,Działania oczekujące na dziś,
+Pension Funds,Fundusze emerytalne,
+Percentage Allocation should be equal to 100%,Przydział Procentowy powinien wynosić 100%,
+Perception Analysis,Analiza percepcji,
+Period,Okres,
+Period Closing Entry,Wpis Kończący Okres,
+Period Closing Voucher,Zamknięcie roku,
+Periodicity,Okresowość,
+Personal Details,Dane osobowe,
+Pharmaceutical,Farmaceutyczny,
+Pharmaceuticals,Farmaceutyczne,
+Physician,Lekarz,
+Piecework,Praca akordowa,
+Pincode,Kod PIN,
+Place Of Supply (State/UT),Miejsce zaopatrzenia (stan / UT),
+Place Order,Złóż zamówienie,
+Plan Name,Nazwa planu,
+Plan for maintenance visits.,Plan wizyt serwisowych.,
+Planned Qty,Planowana ilość,
+"Planned Qty: Quantity, for which, Work Order has been raised, but is pending to be manufactured.","Planowana ilość: ilość, dla której zlecenie pracy zostało podniesione, ale oczekuje na wyprodukowanie.",
+Planning,Planowanie,
+Plants and Machineries,Rośliny i maszyn,
+Please Set Supplier Group in Buying Settings.,Ustaw grupę dostawców w ustawieniach zakupów.,
+Please add a Temporary Opening account in Chart of Accounts,Dodaj konto tymczasowego otwarcia w planie kont,
+Please add the account to root level Company - ,Dodaj konto do poziomu głównego firmy -,
+Please add the remaining benefits {0} to any of the existing component,Dodaj pozostałe korzyści {0} do dowolnego z istniejących komponentów,
+Please check Multi Currency option to allow accounts with other currency,"Proszę sprawdzić multi opcji walutowych, aby umożliwić rachunki w innych walutach",
+Please click on 'Generate Schedule',"Proszę kliknąć na ""Wygeneruj Harmonogram""",
+Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Proszę kliknąć na ""Generowanie Harmonogramu"", aby sprowadzić nr seryjny dodany do pozycji {0}",
+Please click on 'Generate Schedule' to get schedule,"Kliknij na ""Generuj Harmonogram"" aby otrzymać harmonogram",
+Please confirm once you have completed your training,Potwierdź po zakończeniu szkolenia,
+Please create purchase receipt or purchase invoice for the item {0},Utwórz paragon zakupu lub fakturę zakupu elementu {0},
+Please define grade for Threshold 0%,Proszę określić stopień dla progu 0%,
+Please enable Applicable on Booking Actual Expenses,Włącz opcję Rzeczywiste wydatki za rezerwację,
+Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,Włącz Włączone do zamówienia i obowiązujące przy rzeczywistych kosztach rezerwacji,
+Please enable default incoming account before creating Daily Work Summary Group,Włącz domyślne konto przychodzące przed utworzeniem Daily Summary Summary Group,
+Please enable pop-ups,Proszę włączyć pop-upy,
+Please enter 'Is Subcontracted' as Yes or No,"Proszę wprowadź ""Zlecona"" jako Tak lub Nie",
+Please enter API Consumer Key,Wprowadź klucz klienta API,
+Please enter API Consumer Secret,Wprowadź klucz tajny API,
+Please enter Account for Change Amount,Proszę wpisać uwagę do zmiany kwoty,
+Please enter Approving Role or Approving User,Proszę wprowadzić Rolę osoby zatwierdzającej dla użytkownika zatwierdzającego,
+Please enter Cost Center,Wprowadź Centrum kosztów,
+Please enter Delivery Date,Proszę podać datę doręczenia,
+Please enter Employee Id of this sales person,Proszę podać ID pracownika tej osoby ze sprzedaży,
+Please enter Expense Account,Wprowadź konto Wydatków,
+Please enter Item Code to get Batch Number,"Proszę wpisać kod produkt, aby uzyskać numer partii",
+Please enter Item Code to get batch no,Proszę wprowadzić Kod Produktu w celu przyporządkowania serii,
+Please enter Item first,Proszę najpierw wprowadzić Przedmiot,
+Please enter Maintaince Details first,Proszę wprowadzić szczegóły dotyczące konserwacji,
+Please enter Planned Qty for Item {0} at row {1},Proszę podać Planowane Ilości dla pozycji {0} w wierszu {1},
+Please enter Preferred Contact Email,Proszę wpisać Preferowany Kontakt Email,
+Please enter Production Item first,Wprowadź jako pierwszą Produkowaną Rzecz,
+Please enter Purchase Receipt first,Proszę wpierw wprowadzić dokument zakupu,
+Please enter Receipt Document,Proszę podać Otrzymanie dokumentu,
+Please enter Repayment Periods,Proszę wprowadzić okresy spłaty,
+Please enter Reqd by Date,Wprowadź datę realizacji,
+Please enter Woocommerce Server URL,Wprowadź adres URL serwera Woocommerce,
+Please enter Write Off Account,Proszę zdefiniować konto odpisów,
+Please enter atleast 1 invoice in the table,Wprowadź co najmniej jedną fakturę do tabelki,
+Please enter company first,Proszę najpierw wpisać Firmę,
+Please enter company name first,Proszę najpierw wpisać nazwę Firmy,
+Please enter default currency in Company Master,Proszę dodać domyślną walutę w Głównych Ustawieniach Firmy,
+Please enter message before sending,Proszę wpisać wiadomość przed wysłaniem,
+Please enter parent cost center,Proszę podać nadrzędne centrum kosztów,
+Please enter quantity for Item {0},Wprowadź ilość dla przedmiotu {0},
+Please enter repayment Amount,Wpisz Kwota spłaty,
+Please enter valid Financial Year Start and End Dates,Proszę wpisać poprawny rok obrotowy od daty rozpoczęcia i zakończenia,
+Please enter valid email address,Proszę wprowadzić poprawny adres email,
+Please enter {0} first,Podaj {0} pierwszy,
+Please fill in all the details to generate Assessment Result.,"Proszę wypełnić wszystkie szczegóły, aby wygenerować wynik oceny.",
+Please identify/create Account (Group) for type - {0},Określ / utwórz konto (grupę) dla typu - {0},
+Please identify/create Account (Ledger) for type - {0},Zidentyfikuj / utwórz konto (księga) dla typu - {0},
+Please login as another user to register on Marketplace,"Zaloguj się jako inny użytkownik, aby zarejestrować się na rynku",
+Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,"Upewnij się, że na pewno chcesz usunąć wszystkie transakcje dla tej firmy. Twoje dane podstawowe pozostanie tak jak jest. Ta akcja nie można cofnąć.",
+Please mention Basic and HRA component in Company,Proszę wspomnieć o komponencie Basic i HRA w firmie,
+Please mention Round Off Account in Company,Proszę określić konto do zaokrągleń kwot w firmie,
+Please mention Round Off Cost Center in Company,Powołaj zaokrąglić centrum kosztów w Spółce,
+Please mention the Lead Name in Lead {0},Zapoznaj się z nazwą wiodącego wiodącego {0},
+Please pull items from Delivery Note,Wyciągnij elementy z dowodu dostawy,
+Please register the SIREN number in the company information file,Zarejestruj numer SIREN w pliku z informacjami o firmie,
+Please remove this Invoice {0} from C-Form {1},Proszę usunąć tę fakturę {0} z C-Form {1},
+Please save the patient first,Najpierw zapisz pacjenta,
+Please save the report again to rebuild or update,"Zapisz raport ponownie, aby go odbudować lub zaktualizować",
+"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Proszę wybrać Przyznana kwota, faktury i faktury Rodzaj numer w conajmniej jednym rzędzie",
+Please select Apply Discount On,Proszę wybrać Zastosuj RABAT,
+Please select BOM against item {0},Wybierz zestawienie materiałów w odniesieniu do pozycji {0},
+Please select BOM for Item in Row {0},Proszę wybrać LM dla pozycji w wierszu {0},
+Please select BOM in BOM field for Item {0},Proszę wybrać LM w dziedzinie BOM dla pozycji {0},
+Please select Category first,Proszę najpierw wybrać kategorię,
+Please select Charge Type first,Najpierw wybierz typ opłaty,
+Please select Company,Proszę wybrać firmę,
+Please select Company and Designation,Wybierz firmę i oznaczenie,
+Please select Company and Posting Date to getting entries,"Wybierz Firmę i Data księgowania, aby uzyskać wpisy",
+Please select Company first,Najpierw wybierz firmę,
+Please select Completion Date for Completed Asset Maintenance Log,Proszę wybrać opcję Data zakończenia dla ukończonego dziennika konserwacji zasobów,
+Please select Completion Date for Completed Repair,Proszę wybrać datę zakończenia naprawy zakończonej,
+Please select Course,Proszę wybrać Kurs,
+Please select Drug,Proszę wybrać lek,
+Please select Employee,Wybierz pracownika,
+Please select Existing Company for creating Chart of Accounts,Wybierz istniejący podmiot do tworzenia planu kont,
+Please select Healthcare Service,Wybierz Healthcare Service,
+"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Proszę wybrać produkt, gdzie &quot;Czy Pozycja Zdjęcie&quot; brzmi &quot;Nie&quot; i &quot;Czy Sales Item&quot; brzmi &quot;Tak&quot;, a nie ma innego Bundle wyrobów",
+Please select Maintenance Status as Completed or remove Completion Date,Wybierz Stan konserwacji jako Zakończony lub usuń datę ukończenia,
+Please select Party Type first,Wybierz typ pierwszy Party,
+Please select Patient,Proszę wybrać Pacjenta,
+Please select Patient to get Lab Tests,"Wybierz pacjenta, aby uzyskać testy laboratoryjne",
+Please select Posting Date before selecting Party,Proszę wybrać Data księgowania przed wybraniem Stronę,
+Please select Posting Date first,Najpierw wybierz zamieszczenia Data,
+Please select Price List,Wybierz Cennik,
+Please select Program,Proszę wybrać Program,
+Please select Qty against item {0},Wybierz Qty przeciwko pozycji {0},
+Please select Sample Retention Warehouse in Stock Settings first,Najpierw wybierz Sample Retention Warehouse w ustawieniach magazynowych,
+Please select Start Date and End Date for Item {0},Wybierz Datę Startu i Zakończenia dla elementu {0},
+Please select Student Admission which is mandatory for the paid student applicant,"Wybierz Wstęp studenta, który jest obowiązkowy dla płatnego studenta",
+Please select a BOM,Wybierz zestawienie materiałów,
+Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,"Wybierz partię dla elementu {0}. Nie można znaleźć pojedynczej partii, która spełnia ten wymóg",
+Please select a Company,Wybierz firmę,
+Please select a batch,Wybierz partię,
+Please select a csv file,Proszę wybrać plik .csv,
+Please select a field to edit from numpad,Proszę wybrać pole do edycji z numpadu,
+Please select a table,Proszę wybrać tabelę,
+Please select a valid Date,Proszę wybrać prawidłową datę,
+Please select a value for {0} quotation_to {1},Proszę wprowadzić wartość dla wyceny {0} {1},
+Please select a warehouse,Proszę wybrać magazyn,
+Please select at least one domain.,Wybierz co najmniej jedną domenę.,
+Please select correct account,Proszę wybrać prawidłową konto,
+Please select date,Proszę wybrać datę,
+Please select item code,Wybierz kod produktu,
+Please select month and year,Wybierz miesiąc i rok,
+Please select prefix first,Wybierz prefiks,
+Please select the Company,Wybierz firmę,
+Please select the Multiple Tier Program type for more than one collection rules.,Wybierz typ programu dla wielu poziomów dla więcej niż jednej reguły zbierania.,
+Please select the assessment group other than 'All Assessment Groups',Proszę wybrać grupę oceniającą inną niż &quot;Wszystkie grupy oceny&quot;,
+Please select the document type first,Najpierw wybierz typ dokumentu,
+Please select weekly off day,Wybierz tygodniowe dni wolne,
+Please select {0},Proszę wybrać {0},
+Please select {0} first,Proszę najpierw wybrać {0},
+Please set 'Apply Additional Discount On',Proszę ustawić &quot;Zastosuj dodatkowe zniżki na &#39;,
+Please set 'Asset Depreciation Cost Center' in Company {0},Proszę ustawić &quot;aktywa Amortyzacja Cost Center&quot; w towarzystwie {0},
+Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Proszę ustaw &#39;wpływ konto / strata na aktywach Spółki w unieszkodliwianie &quot;{0},
+Please set Account in Warehouse {0} or Default Inventory Account in Company {1},Ustaw konto w magazynie {0} lub domyślne konto zapasów w firmie {1},
+Please set B2C Limit in GST Settings.,Ustaw Limit B2C w Ustawieniach GST.,
+Please set Company,Proszę ustawić firmę,
+Please set Company filter blank if Group By is 'Company',"Proszę wyłączyć filtr firmy, jeśli Group By jest &quot;Company&quot;",
+Please set Default Payroll Payable Account in Company {0},Proszę ustawić domyślny Payroll konto płatne w Spółce {0},
+Please set Depreciation related Accounts in Asset Category {0} or Company {1},Proszę ustawić amortyzacyjny dotyczący Konta aktywów z kategorii {0} lub {1} Spółki,
+Please set Email Address,Proszę ustawić adres e-mail,
+Please set GST Accounts in GST Settings,Ustaw Konta GST w Ustawieniach GST,
+Please set Hotel Room Rate on {},Ustaw stawkę hotelową na {},
+Please set Number of Depreciations Booked,Proszę ustawić ilość amortyzacji zarezerwowano,
+Please set Unrealized Exchange Gain/Loss Account in Company {0},Ustaw niezrealizowane konto zysku / straty w firmie {0},
+Please set User ID field in an Employee record to set Employee Role,Proszę ustawić pole ID użytkownika w rekordzie pracownika do roli pracownika zestawu,
+Please set a default Holiday List for Employee {0} or Company {1},Proszę ustawić domyślnej listy wypoczynkowe dla pracowników {0} lub {1} firmy,
+Please set account in Warehouse {0},Ustaw konto w magazynie {0},
+Please set an active menu for Restaurant {0},Ustaw aktywne menu restauracji {0},
+Please set associated account in Tax Withholding Category {0} against Company {1},Ustaw powiązane konto w kategorii U źródła poboru podatku {0} względem firmy {1},
+Please set at least one row in the Taxes and Charges Table,Ustaw co najmniej jeden wiersz w tabeli Podatki i opłaty,
+Please set default Cash or Bank account in Mode of Payment {0},Proszę ustawić domyślne konto Gotówka lub Bank dla płatności typu {0},
+Please set default account in Salary Component {0},Proszę ustawić domyślne konto wynagrodzenia komponentu {0},
+Please set default customer in Restaurant Settings,Ustaw domyślnego klienta w Ustawieniach restauracji,
+Please set default template for Leave Approval Notification in HR Settings.,Ustaw domyślny szablon powiadomienia o pozostawieniu zatwierdzania w Ustawieniach HR.,
+Please set default template for Leave Status Notification in HR Settings.,Ustaw domyślny szablon dla Opuszczania powiadomienia o statusie w Ustawieniach HR.,
+Please set default {0} in Company {1},Proszę ustawić domyślny {0} w towarzystwie {1},
+Please set filter based on Item or Warehouse,Proszę ustawić filtr na podstawie pkt lub magazynie,
+Please set leave policy for employee {0} in Employee / Grade record,Ustaw zasadę urlopu dla pracownika {0} w rekordzie Pracownicy / stanowisko,
+Please set recurring after saving,Proszę ustawić cykliczne po zapisaniu,
+Please set the Company,Proszę ustawić firmę,
+Please set the Customer Address,Ustaw adres klienta,
+Please set the Date Of Joining for employee {0},Proszę ustawić datę dołączenia do pracownika {0},
+Please set the Default Cost Center in {0} company.,Ustaw domyślne miejsce powstawania kosztów w firmie {0}.,
+Please set the Email ID for the Student to send the Payment Request,"Proszę podać identyfikator e-mailowy studenta, aby wysłać żądanie płatności",
+Please set the Item Code first,Proszę najpierw ustawić kod pozycji,
+Please set the Payment Schedule,Ustaw harmonogram płatności,
+Please set the series to be used.,"Ustaw serię, która ma być używana.",
+Please set {0} for address {1},Ustaw {0} na adres {1},
+Please setup Students under Student Groups,Proszę ustawić Studentów w grupach studenckich,
+Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',"Podziel się swoją opinią na szkolenie, klikając link &quot;Szkolenia zwrotne&quot;, a następnie &quot;Nowy&quot;",
+Please specify Company,Sprecyzuj Firmę,
+Please specify Company to proceed,Sprecyzuj firmę aby przejść dalej,
+Please specify a valid Row ID for row {0} in table {1},Proszę podać poprawny identyfikator wiersz dla rzędu {0} w tabeli {1},
+Please specify at least one attribute in the Attributes table,Proszę zaznaczyć co najmniej jeden atrybut w tabeli atrybutów,
+Please specify currency in Company,Proszę określić walutę w Spółce,
+Please specify either Quantity or Valuation Rate or both,Podaj dokładnie Ilość lub Stawkę lub obie,
+Please specify from/to range,Proszę określić zakres od/do,
+Please supply the specified items at the best possible rates,Proszę dostarczyć określone przedmioty w najlepszych możliwych cenach,
+Please update your status for this training event,Proszę zaktualizować swój status w tym szkoleniu,
+Please wait 3 days before resending the reminder.,Poczekaj 3 dni przed ponownym wysłaniem przypomnienia.,
+Point of Sale,Punkt Sprzedaży (POS),
+Point-of-Sale,Punkt sprzedaży,
+Point-of-Sale Profile,Point-of-Sale profil,
+Portal,Portal,
+Portal Settings,Ustawienia,
+Possible Supplier,Dostawca możliwe,
+Postal Expenses,Wydatki pocztowe,
+Posting Date,Data publikacji,
+Posting Date cannot be future date,Data publikacji nie może być datą przyszłą,
+Posting Time,Czas publikacji,
+Posting date and posting time is mandatory,Delegowanie datę i czas delegowania jest obowiązkowe,
+Posting timestamp must be after {0},Datownik musi byś ustawiony przed {0},
+Potential opportunities for selling.,Potencjalne szanse na sprzedaż.,
+Practitioner Schedule,Harmonogram praktyk,
+Pre Sales,Przedsprzedaż,
+Preference,Pierwszeństwo,
+Prescribed Procedures,Zalecane procedury,
+Prescription,Recepta,
+Prescription Dosage,Dawka leku na receptę,
+Prescription Duration,Czas trwania recepty,
+Prescriptions,Recepty,
+Present,Obecny,
+Prev,Poprzedni,
+Preview,Podgląd,
+Preview Salary Slip,Podgląd Zarobki Slip,
+Previous Financial Year is not closed,Poprzedni rok finansowy nie jest zamknięta,
+Price,Cena,
+Price List,Cennik,
+Price List Currency not selected,Nie wybrano Cennika w Walucie,
+Price List Rate,Wartość w cenniku,
+Price List master.,Ustawienia Cennika.,
+Price List must be applicable for Buying or Selling,Cennik musi być przyporządkowany do kupna albo sprzedaży,
+Price List {0} is disabled or does not exist,Cennik {0} jest wyłączona lub nie istnieje,
+Price or product discount slabs are required,Wymagane są płyty cenowe lub rabatowe na produkty,
+Pricing,Ustalanie cen,
+Pricing Rule,Zasada ustalania cen,
+"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Wycena Zasada jest najpierw wybiera się na podstawie ""Zastosuj Na"" polu, które może być pozycja, poz Grupa lub Marka.",
+"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Wycena Zasada jest nadpisanie cennik / określenie procentowego rabatu, w oparciu o pewne kryteria.",
+Pricing Rule {0} is updated,Zaktualizowano regułę cenową {0},
+Pricing Rules are further filtered based on quantity.,Zasady ustalania cen są dalej filtrowane na podstawie ilości.,
+Primary Address Details,Podstawowe dane adresowe,
+Primary Contact Details,Podstawowe dane kontaktowe,
+Principal Amount,Główna kwota,
+Print Format,Format Druku,
+Print IRS 1099 Forms,Drukuj formularze IRS 1099,
+Print Report Card,Wydrukuj kartę raportu,
+Print Settings,Ustawienia drukowania,
+Print and Stationery,Druk i Materiały Biurowe,
+Print settings updated in respective print format,Ustawienia drukowania zaktualizowane w odpowiednim formacie druku,
+Print taxes with zero amount,Drukowanie podatków z zerową kwotą,
+Printing and Branding,Drukowanie i firmowanie,
+Private Equity,Kapitał prywatny,
+Privilege Leave,Nieobecność z przywileju,
+Probation,Wyrok lub staż,
+Probationary Period,Okres próbny,
+Procedure,Procedura,
+Process Day Book Data,Dane książki dnia procesu,
+Process Master Data,Przetwarzaj dane podstawowe,
+Processing Chart of Accounts and Parties,Przetwarzanie planu kont i stron,
+Processing Items and UOMs,Przetwarzanie elementów i UOM,
+Processing Party Addresses,Adresy stron przetwarzających,
+Processing Vouchers,Bony przetwarzające,
+Procurement,Zaopatrzenie,
+Produced Qty,Wytworzona ilość,
+Product,Produkt,
+Product Bundle,Pakiet produktów,
+Product Search,Wyszukiwarka produktów,
+Production,Produkcja,
+Production Item,Pozycja Produkcja,
+Products,Produkty,
+Profit and Loss,Zyski i Straty,
+Profit for the year,Zysk za rok,
+Program,Program,
+Program in the Fee Structure and Student Group {0} are different.,Program w strukturze opłat i grupa studencka {0} są różne.,
+Program {0} does not exist.,Program {0} nie istnieje.,
+Program: ,Program:,
+Progress % for a task cannot be more than 100.,Postęp% dla zadania nie może zawierać więcej niż 100.,
+Project Collaboration Invitation,Projekt zaproszenie Współpraca,
+Project Id,Projekt Id,
+Project Manager,Menadżer projektu,
+Project Name,Nazwa Projektu,
+Project Start Date,Data startu projektu,
+Project Status,Status projektu,
+Project Summary for {0},Podsumowanie projektu dla {0},
+Project Update.,Aktualizacja projektu.,
+Project Value,Wartość projektu,
+Project activity / task.,Czynność / zadanie projektu,
+Project master.,Dyrektor projektu,
+Projected,Prognozowany,
+Projected Qty,Przewidywana ilość,
+Projected Quantity Formula,Formuła przewidywanej ilości,
+Projects,Projekty,
+Property,Właściwość,
+Property already added,Właściwość została już dodana,
+Proposal Writing,Pisanie wniosku,
+Proposal/Price Quote,Propozycja/Oferta cenowa,
+Prospecting,Poszukiwania,
+Provisional Profit / Loss (Credit),Rezerwowy Zysk / Strata (Credit),
+Publications,Publikacje,
+Publish Items on Website,Publikowanie przedmioty na stronie internetowej,
+Published,Opublikowany,
+Publishing,Działalność wydawnicza,
+Purchase,Zakup,
+Purchase Amount,Kwota zakupu,
+Purchase Date,Data zakupu,
+Purchase Invoice,Faktura zakupu,
+Purchase Invoice {0} is already submitted,Faktura zakupu {0} została już wysłana,
+Purchase Manager,Menadżer Zakupów,
+Purchase Master Manager,Główny Menadżer Zakupów,
+Purchase Order,Zamówienie,
+Purchase Order Amount,Kwota zamówienia zakupu,
+Purchase Order Amount(Company Currency),Kwota zamówienia zakupu (waluta firmy),
+Purchase Order Date,Data zamówienia zakupu,
+Purchase Order Items not received on time,Elementy zamówienia zakupu nie zostały dostarczone na czas,
+Purchase Order number required for Item {0},Numer Zamówienia Kupna wymagany do {0},
+Purchase Order to Payment,Zamówienie zakupu do płatności,
+Purchase Order {0} is not submitted,Zamówienia Kupna {0} nie zostało wysłane,
+Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Zlecenia zakupu nie są dozwolone w {0} z powodu karty wyników {1}.,
+Purchase Orders given to Suppliers.,Zamówienia Kupna dane Dostawcom,
+Purchase Price List,Cennik zakupowy,
+Purchase Receipt,Potwierdzenie zakupu,
+Purchase Receipt {0} is not submitted,Potwierdzenie zakupu {0} nie zostało wysłane,
+Purchase Tax Template,Szablon podatkowy zakupów,
+Purchase User,Zakup użytkownika,
+Purchase orders help you plan and follow up on your purchases,Zamówienia pomoże Ci zaplanować i śledzić na zakupy,
+Purchasing,Dostawy,
+Purpose must be one of {0},Cel musi być jednym z {0},
+Qty,Ilość,
+Qty To Manufacture,Ilość do wyprodukowania,
+Qty Total,Ilość całkowita,
+Qty for {0},Ilość dla {0},
+Qualification,Kwalifikacja,
+Quality,Jakość,
+Quality Action,Akcja jakości,
+Quality Goal.,Cel jakości.,
+Quality Inspection,Kontrola jakości,
+Quality Inspection: {0} is not submitted for the item: {1} in row {2},Kontrola jakości: {0} nie jest przesyłany dla przedmiotu: {1} w wierszu {2},
+Quality Management,Zarządzanie jakością,
+Quality Meeting,Spotkanie jakościowe,
+Quality Procedure,Procedura jakości,
+Quality Procedure.,Procedura jakości.,
+Quality Review,Przegląd jakości,
+Quantity,Ilość,
+Quantity for Item {0} must be less than {1},Ilość dla przedmiotu {0} musi być mniejsza niż {1},
+Quantity in row {0} ({1}) must be same as manufactured quantity {2},Ilość w rzędzie  {0} ({1}) musi być taka sama jak wyprodukowana ilość {2},
+Quantity must be less than or equal to {0},Ilość musi być mniejsze niż lub równe {0},
+Quantity must not be more than {0},Ilość nie może być większa niż {0},
+Quantity required for Item {0} in row {1},Ilość wymagana dla Przedmiotu {0} w rzędzie {1},
+Quantity should be greater than 0,Ilość powinna być większa niż 0,
+Quantity to Make,Ilość do zrobienia,
+Quantity to Manufacture must be greater than 0.,Ilość do produkcji musi być większy niż 0 ° C.,
+Quantity to Produce,Ilość do wyprodukowania,
+Quantity to Produce can not be less than Zero,Ilość do wyprodukowania nie może być mniejsza niż zero,
+Query Options,Opcje Zapytania,
+Queued for replacing the BOM. It may take a few minutes.,W kolejce do zastąpienia BOM. Może to potrwać kilka minut.,
+Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Usługa kolejkowania aktualizacji najnowszej ceny we wszystkich materiałach. Może potrwać kilka minut.,
+Quick Journal Entry,Szybkie Księgowanie,
+Quot Count,Quot Count,
+Quot/Lead %,Kwota / kwota procentowa,
+Quotation,Wycena,
+Quotation {0} is cancelled,Oferta {0} jest anulowana,
+Quotation {0} not of type {1},Oferta {0} nie jest typem {1},
+Quotations,Notowania,
+"Quotations are proposals, bids you have sent to your customers","Notowania są propozycje, oferty Wysłane do klientów",
+Quotations received from Suppliers.,Wyceny otrzymane od dostawców,
+Quotations: ,Cytaty:,
+Quotes to Leads or Customers.,Wycena dla Tropów albo Klientów,
+RFQs are not allowed for {0} due to a scorecard standing of {1},Zlecenia RFQ nie są dozwolone w {0} z powodu karty wyników {1},
+Range,Przedział,
+Rate,Stawka,
+Rate:,Oceniać:,
+Rating,Ocena,
+Raw Material,Surowiec,
+Raw Materials,Surowy materiał,
+Raw Materials cannot be blank.,Surowce nie może być puste.,
+Re-open,Otwórz ponownie,
+Read blog,Czytaj blog,
+Read the ERPNext Manual,Przeczytać instrukcję ERPNext,
+Reading Uploaded File,Odczyt przesłanego pliku,
+Real Estate,Nieruchomości,
+Reason For Putting On Hold,Powód do zawieszenia,
+Reason for Hold,Powód wstrzymania,
+Reason for hold: ,Powód wstrzymania:,
+Receipt,Paragon,
+Receipt document must be submitted,Otrzymanie dokumentu należy składać,
+Receivable,Należności,
+Receivable Account,Konto Należności,
+Received,Otrzymano,
+Received On,Otrzymana w dniu,
+Received Quantity,Otrzymana ilość,
+Received Stock Entries,Otrzymane wpisy giełdowe,
+Receiver List is empty. Please create Receiver List,Lista odbiorców jest pusta. Proszę stworzyć Listę Odbiorców,
+Recipients,Adresaci,
+Reconcile,Uzgodnij,
+"Record of all communications of type email, phone, chat, visit, etc.","Zapis wszystkich komunikatów typu e-mail, telefon, czat, wizyty, itd",
+Records,Dokumentacja,
+Redirect URL,przekierowanie,
+Ref,Ref,
+Ref Date,Ref Data,
+Reference,Referencja,
+Reference #{0} dated {1},Odnośnik #{0} z datą {1},
+Reference Date,Data Odniesienia,
+Reference Doctype must be one of {0},Doctype referencyjny musi być jednym z {0},
+Reference Document,Dokument referencyjny,
+Reference Document Type,Oznaczenie typu dokumentu,
+Reference No & Reference Date is required for {0},Nr Odniesienia & Data Odniesienia jest wymagana do {0},
+Reference No and Reference Date is mandatory for Bank transaction,Numer referencyjny i data jest obowiązkowe dla transakcji Banku,
+Reference No is mandatory if you entered Reference Date,Nr Odniesienia jest obowiązkowy jest wprowadzono Datę Odniesienia,
+Reference No.,Nr referencyjny.,
+Reference Number,Numer Odniesienia,
+Reference Owner,Odniesienie Właściciel,
+Reference Type,Typ Odniesienia,
+"Reference: {0}, Item Code: {1} and Customer: {2}","Odniesienie: {0}, Kod pozycji: {1} i klient: {2}",
+References,Referencje,
+Refresh Token,Odśwież Reklamowe,
+Region,Region,
+Register,Zarejestrować,
+Reject,Odrzucać,
+Rejected,Odrzucono,
+Related,Związane z,
+Relation with Guardian1,Relacja z Guardian1,
+Relation with Guardian2,Relacja z Guardian2,
+Release Date,Data wydania,
+Reload Linked Analysis,Przeładuj połączoną analizę,
+Remaining,Pozostały,
+Remaining Balance,Pozostałe saldo,
+Remarks,Uwagi,
+Reminder to update GSTIN Sent,Przypomnienie o aktualizacji GSTIN wysłanych,
+Remove item if charges is not applicable to that item,"Usuń element, jeśli opłata nie ma zastosowania do tej pozycji",
+Removed items with no change in quantity or value.,Usunięte pozycje bez zmian w ilości lub wartości.,
+Reopen,Otworzyć na nowo,
+Reorder Level,Poziom Uporządkowania,
+Reorder Qty,Ilość do ponownego zamówienia,
+Repeat Customer Revenue,Powtórz Przychody klienta,
+Repeat Customers,Powtarzający się klient,
+Replace BOM and update latest price in all BOMs,Zastąp BOM i zaktualizuj ostatnią cenę we wszystkich materiałach,
+Replied,Odpowiedziane,
+Replies,Odpowiedzi,
+Report,Raport,
+Report Builder,Kreator raportów,
+Report Type,Typ raportu,
+Report Type is mandatory,Typ raportu jest wymagany,
+Reports,Raporty,
+Reqd By Date,Data realizacji,
+Reqd Qty,Wymagana ilość,
+Request for Quotation,Zapytanie ofertowe,
+Request for Quotations,Zapytanie o cenę,
+Request for Raw Materials,Zapytanie o surowce,
+Request for purchase.,Prośba o zakup,
+Request for quotation.,Zapytanie ofertowe.,
+Requesting Site,Strona żądająca,
+Requesting payment against {0} {1} for amount {2},Żądanie zapłatę przed {0} {1} w ilości {2},
+Requestor,Żądający,
+Required On,Wymagane na,
+Required Qty,Wymagana ilość,
+Required Quantity,Wymagana ilość,
+Reschedule,Zmień harmonogram,
+Research,Badania,
+Research & Development,Badania i Rozwój,
+Researcher,Researcher,
+Resend Payment Email,Wyślij ponownie płatności E-mail,
+Reserve Warehouse,Reserve Warehouse,
+Reserved Qty,Zarezerwowana ilość,
+Reserved Qty for Production,Reserved Ilość Produkcji,
+Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Zarezerwowane Ilość na produkcję: Ilość surowców do produkcji artykułów.,
+Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Magazyn Reserved jest obowiązkowy dla Produktu {0} w dostarczonych Surowcach,
+Reserved for manufacturing,Zarezerwowana dla produkcji,
+Reserved for sale,Zarezerwowane na sprzedaż,
+Reserved for sub contracting,Zarezerwowany dla podwykonawców,
+Resistant,Odporny,
+Resolve error and upload again.,Rozwiąż błąd i prześlij ponownie.,
+Responsibilities,Obowiązki,
+Rest Of The World,Reszta świata,
+Restart Subscription,Ponownie uruchom subskrypcję,
+Restaurant,Restauracja,
+Result Date,Data wyniku,
+Result already Submitted,Wynik już przesłany,
+Resume,Wznawianie,
+Retail,Detal,
+Retail & Wholesale,Hurt i Detal,
+Retail Operations,Operacje detaliczne,
+Retained Earnings,Zysk z lat ubiegłych,
+Retention Stock Entry,Wpis do magazynu retencyjnego,
+Retention Stock Entry already created or Sample Quantity not provided,Wpis zapasu retencji już utworzony lub nie podano próbki próbki,
+Return,Powrót,
+Return / Credit Note,Powrót / Credit Note,
+Return / Debit Note,Powrót / noty obciążeniowej,
+Returns,zwroty,
+Reverse Journal Entry,Reverse Journal Entry,
+Review Invitation Sent,Wysłane zaproszenie do recenzji,
+Review and Action,Recenzja i działanie,
+Role,Rola,
+Rooms Booked,Pokoje zarezerwowane,
+Root Company,Firma główna,
+Root Type,Typ Root,
+Root Type is mandatory,Typ Root jest obowiązkowy,
+Root cannot be edited.,Root nie może być edytowany,
+Root cannot have a parent cost center,Root nie może mieć rodzica w centrum kosztów,
+Round Off,Zaokrąglenia,
+Rounded Total,Końcowa zaokrąglona kwota,
+Route,Trasa,
+Row # {0}: ,Wiersz # {0}:,
+Row # {0}: Batch No must be same as {1} {2},"Wiersz # {0}: Batch Nie musi być taki sam, jak {1} {2}",
+Row # {0}: Cannot return more than {1} for Item {2},Wiersz # {0}: Nie można wrócić więcej niż {1} dla pozycji {2},
+Row # {0}: Rate cannot be greater than the rate used in {1} {2},Wiersz {0}: stawka nie może być większa niż stawka stosowana w {1} {2},
+Row # {0}: Serial No is mandatory,Wiersz # {0}: Numer seryjny jest obowiązkowe,
+Row # {0}: Serial No {1} does not match with {2} {3},Wiersz # {0}: Numer seryjny: {1} nie jest zgodny z {2} {3},
+Row #{0} (Payment Table): Amount must be negative,Wiersz nr {0} (tabela płatności): kwota musi być ujemna,
+Row #{0} (Payment Table): Amount must be positive,Wiersz nr {0} (tabela płatności): kwota musi być dodatnia,
+Row #{0}: Account {1} does not belong to company {2},Wiersz nr {0}: konto {1} nie należy do firmy {2},
+Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Wiersz {0}: alokowana kwota nie może być większa niż kwota pozostająca do spłaty.,
+"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Wiersz # {0}: {1} aktywami nie mogą być składane, jest już {2}",
+Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,"Wiersz nr {0}: nie można ustawić wartości Rate, jeśli kwota jest większa niż kwota rozliczona dla elementu {1}.",
+Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Wiersz # {0}: Data Rozliczenie {1} nie może być wcześniejsza niż data Czek {2},
+Row #{0}: Duplicate entry in References {1} {2},Wiersz # {0}: Duplikuj wpis w odsyłaczach {1} {2},
+Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Wiersz # {0}: oczekiwana data dostarczenia nie może być poprzedzona datą zamówienia zakupu,
+Row #{0}: Item added,Wiersz # {0}: element dodany,
+Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Wiersz # {0}: Journal Entry {1} nie masz konta {2} lub już porównywana z innym kuponie,
+Row #{0}: Not allowed to change Supplier as Purchase Order already exists,"Wiersz # {0}: Nie wolno zmienić dostawcę, jak już istnieje Zamówienie",
+Row #{0}: Please set reorder quantity,Wiersz # {0}: Proszę ustawić ilość zmienić kolejność,
+Row #{0}: Please specify Serial No for Item {1},Wiersz # {0}: Proszę podać nr seryjny dla pozycji {1},
+Row #{0}: Qty increased by 1,Wiersz # {0}: Ilość zwiększona o 1,
+Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,"Wiersz # {0}: Cena musi być taki sam, jak {1}: {2} ({3} / {4})",
+Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Wiersz # {0}: Typ dokumentu referencyjnego musi być jednym z wydatków roszczenia lub wpisu do dziennika,
+"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Wiersz # {0}: Reference Document Type musi być jednym z Zamówieniem, faktura zakupu lub Journal Entry",
+Row #{0}: Rejected Qty can not be entered in Purchase Return,Wiersz # {0}: Odrzucone Ilość nie może być wprowadzone w Purchase Powrót,
+Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Wiersz # {0}: Odrzucone Magazyn jest obowiązkowe przed odrzucony poz {1},
+Row #{0}: Reqd by Date cannot be before Transaction Date,Wiersz nr {0}: Data realizacji nie może być wcześniejsza od daty transakcji,
+Row #{0}: Set Supplier for item {1},Wiersz # {0}: Ustaw Dostawca dla pozycji {1},
+Row #{0}: Status must be {1} for Invoice Discounting {2},Wiersz # {0}: status musi być {1} dla rabatu na faktury {2},
+"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Wiersz # {0}: partia {1} ma tylko {2} qty. Wybierz inną partię, która ma {3} qty dostępną lub podzielisz wiersz na wiele wierszy, aby dostarczyć / wydać z wielu partii",
+Row #{0}: Timings conflicts with row {1},Wiersz # {0}: taktowania konflikty z rzędu {1},
+Row #{0}: {1} can not be negative for item {2},Wiersz # {0}: {1} nie może być negatywne dla pozycji {2},
+Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Wiersz nr {0}: Kwota nie może być większa niż oczekiwaniu Kwota wobec Kosztów zastrzeżenia {1}. W oczekiwaniu Kwota jest {2},
+Row {0} : Operation is required against the raw material item {1},Wiersz {0}: operacja jest wymagana względem elementu surowcowego {1},
+Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Wiersz {0} # Przydzielona kwota {1} nie może być większa od kwoty nieodebranej {2},
+Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Wiersz {0} # Element {1} nie może zostać przeniesiony więcej niż {2} na zamówienie {3},
+Row {0}# Paid Amount cannot be greater than requested advance amount,Wiersz {0} # Płatna kwota nie może być większa niż żądana kwota zaliczki,
+Row {0}: Activity Type is mandatory.,Wiersz {0}: Typ aktywny jest obowiązkowe.,
+Row {0}: Advance against Customer must be credit,Wiersz {0}: Zaliczka  Klienta jest po stronie kredytowej,
+Row {0}: Advance against Supplier must be debit,Wiersz {0}: Zaliczka Dostawcy jest po stronie debetowej,
+Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Wiersz {0}: Przyznana kwota {1} musi być mniejsza lub równa kwocie Entry Płatność {2},
+Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Wiersz {0}: Przyznana kwota {1} musi być mniejsza lub równa pozostałej kwoty faktury {2},
+Row {0}: An Reorder entry already exists for this warehouse {1},"Wiersz {0}: Zapis ponownego zamawiania dla tego magazynu, {1}",
+Row {0}: Bill of Materials not found for the Item {1},Wiersz {0}: Bill of Materials nie znaleziono Item {1},
+Row {0}: Conversion Factor is mandatory,Wiersz {0}: Współczynnik konwersji jest obowiązkowe,
+Row {0}: Cost center is required for an item {1},Wiersz {0}: wymagany jest koszt centrum dla elementu {1},
+Row {0}: Credit entry can not be linked with a {1},Wiersz {0}: wejście kredytowe nie mogą być powiązane z {1},
+Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Wiersz {0}: Waluta BOM # {1} powinna być równa wybranej walucie {2},
+Row {0}: Debit entry can not be linked with a {1},Wiersz {0}: Debit wpis nie może być związana z {1},
+Row {0}: Depreciation Start Date is required,Wiersz {0}: Wymagana data rozpoczęcia amortyzacji,
+Row {0}: Enter location for the asset item {1},Wiersz {0}: wpisz lokalizację dla elementu zasobu {1},
+Row {0}: Exchange Rate is mandatory,Wiersz {0}: Kurs wymiany jest obowiązkowe,
+Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Wiersz {0}: oczekiwana wartość po przydatności musi być mniejsza niż kwota zakupu brutto,
+Row {0}: From Time and To Time is mandatory.,Wiersz {0}: od czasu do czasu i jest obowiązkowe.,
+Row {0}: From Time and To Time of {1} is overlapping with {2},Wiersz {0}: od czasu do czasu i od {1} pokrywa się z {2},
+Row {0}: From time must be less than to time,Wiersz {0}: Od czasu musi być mniej niż do czasu,
+Row {0}: Hours value must be greater than zero.,Wiersz {0}: Godziny wartość musi być większa od zera.,
+Row {0}: Invalid reference {1},Wiersz {0}: Nieprawidłowy odniesienia {1},
+Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Wiersz {0}: Party / konto nie jest zgodny z {1} / {2} w {3} {4},
+Row {0}: Party Type and Party is required for Receivable / Payable account {1},Wiersz {0}: Typ i Partia Partia jest wymagane w przypadku otrzymania / rachunku Płatne {1},
+Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Wiersz {0}: Płatność przeciwko sprzedaży / Zamówienia powinny być zawsze oznaczone jako góry,
+Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Wiersz {0}: Proszę sprawdzić ""Czy Advance"" przeciw konta {1}, jeśli jest to zaliczka wpis.",
+Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,Wiersz {0}: należy ustawić w Powodzie zwolnienia z podatku w podatkach od sprzedaży i opłatach,
+Row {0}: Please set the Mode of Payment in Payment Schedule,Wiersz {0}: ustaw tryb płatności w harmonogramie płatności,
+Row {0}: Please set the correct code on Mode of Payment {1},Wiersz {0}: ustaw prawidłowy kod w trybie płatności {1},
+Row {0}: Qty is mandatory,Wiersz {0}: Ilość jest obowiązkowe,
+Row {0}: Quality Inspection rejected for item {1},Wiersz {0}: Kontrola jakości odrzucona dla elementu {1},
+Row {0}: UOM Conversion Factor is mandatory,Wiersz {0}: JM Współczynnik konwersji jest obowiązkowe,
+Row {0}: select the workstation against the operation {1},Wiersz {0}: wybierz stację roboczą w stosunku do operacji {1},
+Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Wiersz {0}: {1} wymagane numery seryjne dla elementu {2}. Podałeś {3}.,
+Row {0}: {1} must be greater than 0,Wiersz {0}: {1} musi być większy niż 0,
+Row {0}: {1} {2} does not match with {3},Wiersz {0}: {1} {2} nie zgadza się z {3},
+Row {0}:Start Date must be before End Date,Wiersz {0}: Data Początku musi być przed Datą Końca,
+Rows with duplicate due dates in other rows were found: {0},Znaleziono wiersze z powtarzającymi się datami w innych wierszach: {0},
+Rules for adding shipping costs.,Zasady naliczania kosztów transportu.,
+Rules for applying pricing and discount.,Zasady określania cen i zniżek,
+SGST Amount,Kwota SGST,
+Safety Stock,Bezpieczeństwo Zdjęcie,
+Salary,Wynagrodzenia,
+Salary Slip ID,Wynagrodzenie Slip ID,
+Salary Slip of employee {0} already created for this period,Wynagrodzenie Slip pracownika {0} już stworzony dla tego okresu,
+Salary Slip of employee {0} already created for time sheet {1},Slip Wynagrodzenie pracownika {0} już stworzony dla arkusza czasu {1},
+Salary Slip submitted for period from {0} to {1},Przesłane wynagrodzenie za okres od {0} do {1},
+Salary Structure Assignment for Employee already exists,Przydział struktury wynagrodzeń dla pracownika już istnieje,
+Salary Structure Missing,Struktura Wynagrodzenie Brakujący,
+Salary Structure must be submitted before submission of Tax Ememption Declaration,Struktura wynagrodzeń musi zostać złożona przed złożeniem deklaracji zwolnienia podatkowego,
+Salary Structure not found for employee {0} and date {1},Nie znaleziono struktury wynagrodzenia dla pracownika {0} i daty {1},
+Salary Structure should have flexible benefit component(s) to dispense benefit amount,Struktura wynagrodzeń powinna mieć elastyczny składnik (-y) świadczeń w celu przyznania kwoty świadczenia,
+"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.",Wynagrodzenie już przetwarzane w okresie od {0} i {1} Zostaw okresu stosowania nie może być pomiędzy tym zakresie dat.,
+Sales,Sprzedaż,
+Sales Account,Konto sprzedaży,
+Sales Expenses,Koszty sprzedaży,
+Sales Funnel,Lejek sprzedaży,
+Sales Invoice,Faktura sprzedaży,
+Sales Invoice {0} has already been submitted,Faktura Sprzedaży {0} została już wprowadzona,
+Sales Invoice {0} must be cancelled before cancelling this Sales Order,Faktura Sprzedaży {0} powinna być anulowana przed anulowaniem samego Zlecenia Sprzedaży,
+Sales Manager,Menadżer Sprzedaży,
+Sales Master Manager,Główny Menadżer Sprzedaży,
+Sales Order,Zlecenie sprzedaży,
+Sales Order Item,Pozycja Zlecenia Sprzedaży,
+Sales Order required for Item {0},Zlecenie Sprzedaży jest wymagane dla Elementu {0},
+Sales Order to Payment,Płatności do zamówienia sprzedaży,
+Sales Order {0} is not submitted,Zlecenie Sprzedaży {0} nie jest jeszcze złożone,
+Sales Order {0} is not valid,Zlecenie Sprzedaży {0} jest niepoprawne,
+Sales Order {0} is {1},Zamówienie sprzedaży jest {0} {1},
+Sales Orders,Zlecenia sprzedaży,
+Sales Partner,Partner Sprzedaży,
+Sales Pipeline,Pipeline sprzedaży,
+Sales Price List,Lista cena sprzedaży,
+Sales Return,Zwrot sprzedaży,
+Sales Summary,Podsumowanie sprzedaży,
+Sales Tax Template,Szablon Podatek od sprzedaży,
+Sales Team,Team Sprzedażowy,
+Sales User,Sprzedaż użytkownika,
+Sales and Returns,Sprzedaż i zwroty,
+Sales campaigns.,Kampanie sprzedażowe,
+Sales orders are not available for production,Zamówienia sprzedaży nie są dostępne do produkcji,
+Salutation,Forma grzecznościowa,
+Same Company is entered more than once,Ta sama Spółka wpisana jest więcej niż jeden raz,
+Same item cannot be entered multiple times.,Sama pozycja nie może być wprowadzone wiele razy.,
+Same supplier has been entered multiple times,"Tego samego dostawcy, który został wpisany wielokrotnie",
+Sample,Próba,
+Sample Collection,Kolekcja próbek,
+Sample quantity {0} cannot be more than received quantity {1},Ilość próbki {0} nie może być większa niż ilość odebranej {1},
+Sanctioned,usankcjonowane,
+Sanctioned Amount,Zatwierdzona Kwota,
+Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Usankcjonowane Kwota nie może być większa niż ilość roszczenia w wierszu {0}.,
+Sand,Piasek,
+Saturday,Sobota,
+Saved,Zapisane,
+Saving {0},Zapisywanie {0},
+Scan Barcode,Skanuj kod kreskowy,
+Schedule,Harmonogram,
+Schedule Admission,Zaplanuj wstęp,
+Schedule Course,Plan zajęć,
+Schedule Date,Planowana Data,
+Schedule Discharge,Zaplanuj rozładowanie,
+Scheduled,Zaplanowane,
+Scheduled Upto,Zaplanowane Upto,
+"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Harmonogramy nakładek {0}, czy chcesz kontynuować po przejściu przez zakładki?",
+Score cannot be greater than Maximum Score,Wynik nie może być większa niż maksymalna liczba punktów,
+Score must be less than or equal to 5,Wynik musi być niższy lub równy 5,
+Scorecards,Karty wyników,
+Scrapped,Złomowany,
+Search,Szukaj,
+Search Results,Wyniki wyszukiwania,
+Search Sub Assemblies,Zespoły Szukaj Sub,
+"Search by item code, serial number, batch no or barcode","Wyszukaj według kodu produktu, numeru seryjnego, numeru partii lub kodu kreskowego",
+"Seasonality for setting budgets, targets etc.","Sezonowość ustalania budżetów, cele itd.",
+Secret Key,Sekretny klucz,
+Secretary,Sekretarka,
+Section Code,Kod sekcji,
+Secured Loans,Kredyty Hipoteczne,
+Securities & Commodity Exchanges,Papiery i Notowania Giełdowe,
+Securities and Deposits,Papiery wartościowe i depozyty,
+See All Articles,Zobacz wszystkie artykuły,
+See all open tickets,Zobacz wszystkie otwarte bilety,
+See past orders,Zobacz poprzednie zamówienia,
+See past quotations,Zobacz poprzednie cytaty,
+Select,Wybierz,
+Select Alternate Item,Wybierz opcję Alternatywny przedmiot,
+Select Attribute Values,Wybierz wartości atrybutów,
+Select BOM,Wybierz BOM,
+Select BOM and Qty for Production,Wybierz BOM i ilosc Produkcji,
+"Select BOM, Qty and For Warehouse","Wybierz LM, ilość i magazyn",
+Select Batch,Wybierz opcję Batch,
+Select Batch Numbers,Wybierz numery partii,
+Select Brand...,Wybierz markę ...,
+Select Company,Wybierz firmę,
+Select Company...,Wybierz firmą ...,
+Select Customer,Wybierz klienta,
+Select Days,Wybierz dni,
+Select Default Supplier,Wybierz Domyślne Dostawca,
+Select DocType,Wybierz DocType,
+Select Fiscal Year...,Wybierz rok finansowy ...,
+Select Item (optional),Wybierz pozycję (opcjonalnie),
+Select Items based on Delivery Date,Wybierz pozycje w oparciu o datę dostarczenia,
+Select Items to Manufacture,Wybierz produkty do Manufacture,
+Select Loyalty Program,Wybierz program lojalnościowy,
+Select Patient,Wybierz pacjenta,
+Select Possible Supplier,Wybierz Możliwa Dostawca,
+Select Property,Wybierz właściwość,
+Select Quantity,Wybierz ilość,
+Select Serial Numbers,Wybierz numery seryjne,
+Select Target Warehouse,Wybierz Magazyn docelowy,
+Select Warehouse...,Wybierz magazyn ...,
+Select an account to print in account currency,Wybierz konto do wydrukowania w walucie konta,
+Select an employee to get the employee advance.,"Wybierz pracownika, aby uzyskać awans pracownika.",
+Select at least one value from each of the attributes.,Wybierz co najmniej jedną wartość z każdego z atrybutów.,
+Select change amount account,Wybierz opcję Zmień konto kwotę,
+Select company first,Najpierw wybierz firmę,
+Select students manually for the Activity based Group,Wybierz uczniów ręcznie dla grupy działań,
+Select the customer or supplier.,Wybierz klienta lub dostawcę.,
+Select the nature of your business.,Wybierz charakteru swojej działalności.,
+Select the program first,Najpierw wybierz program,
+Select to add Serial Number.,"Wybierz, aby dodać numer seryjny.",
+Select your Domains,Wybierz swoje domeny,
+Selected Price List should have buying and selling fields checked.,Wybrany cennik powinien mieć sprawdzone pola kupna i sprzedaży.,
+Sell,Sprzedać,
+Selling,Sprzedaż,
+Selling Amount,Kwota sprzedaży,
+Selling Price List,Cennik sprzedaży,
+Selling Rate,Kurs sprzedaży,
+"Selling must be checked, if Applicable For is selected as {0}","Sprzedaż musi być sprawdzona, jeśli dotyczy wybrano jako {0}",
+Send Grant Review Email,Wyślij wiadomość e-mail dotyczącą oceny grantu,
+Send Now,Wyślij teraz,
+Send SMS,Wyślij SMS,
+Send mass SMS to your contacts,Wyślij zbiorczo sms do swoich kontaktów,
+Sensitivity,Wrażliwość,
+Sent,Wysłano,
+Serial No and Batch,Numer seryjny oraz Batch,
+Serial No is mandatory for Item {0},Nr seryjny jest obowiązkowy dla pozycji {0},
+Serial No {0} does not belong to Batch {1},Numer seryjny {0} nie należy do partii {1},
+Serial No {0} does not belong to Delivery Note {1},Nr seryjny {0} nie należy do żadnego potwierdzenia dostawy {1},
+Serial No {0} does not belong to Item {1},Nr seryjny {0} nie należy do żadnej rzeczy {1},
+Serial No {0} does not belong to Warehouse {1},Nr seryjny {0} nie należy do magazynu {1},
+Serial No {0} does not belong to any Warehouse,Nr seryjny: {0} nie należy do żadnego Magazynu,
+Serial No {0} does not exist,Nr seryjny {0} nie istnieje,
+Serial No {0} has already been received,Nr seryjny {0} otrzymano,
+Serial No {0} is under maintenance contract upto {1},Nr seryjny {0} w ramach umowy serwisowej do {1},
+Serial No {0} is under warranty upto {1},Nr seryjny {0} w ramach gwarancji do {1},
+Serial No {0} not found,Nr seryjny {0} nie znaleziono,
+Serial No {0} quantity {1} cannot be a fraction,Nr seryjny {0} dla ilości {1} nie może być ułamkiem,
+Serial Nos Required for Serialized Item {0},Nr-y seryjne Wymagane do szeregowania pozycji {0},
+Serial Number: {0} is already referenced in Sales Invoice: {1},Numer seryjny: {0} znajduje się już w fakturze sprzedaży: {1},
+Serial Numbers,Numer seryjny,
+Serial Numbers in row {0} does not match with Delivery Note,Numery seryjne w wierszu {0} nie pasują do opisu dostawy,
+Serial no {0} has been already returned,Numer seryjny {0} został już zwrócony,
+Serial number {0} entered more than once,Nr seryjny {0} wprowadzony jest więcej niż jeden raz,
+Serialized Inventory,Inwentaryzacja w odcinkach,
+Series Updated,Aktualizacja serii,
+Series Updated Successfully,Seria zaktualizowana,
+Series is mandatory,Serie jest obowiązkowa,
+Series {0} already used in {1},Seria {0} już zostały użyte w {1},
+Service,Usługa,
+Service Expense,Koszty usługi,
+Service Level Agreement,Umowa o poziomie usług,
+Service Level Agreement.,Umowa o poziomie usług.,
+Service Level.,Poziom usług.,
+Service Stop Date cannot be after Service End Date,Data zatrzymania usługi nie może być późniejsza niż data zakończenia usługi,
+Service Stop Date cannot be before Service Start Date,Data zatrzymania usługi nie może być wcześniejsza niż data rozpoczęcia usługi,
+Services,Usługi,
+"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Ustaw wartości domyślne jak firma, waluta, bieżący rok rozliczeniowy, itd.",
+Set Details,Ustaw szczegóły,
+Set New Release Date,Ustaw nową datę wydania,
+Set Project and all Tasks to status {0}?,Ustaw projekt i wszystkie zadania na status {0}?,
+Set Status,Ustaw status,
+Set Tax Rule for shopping cart,Ustaw regułę podatkowa do koszyka,
+Set as Closed,Ustaw jako Zamknięty,
+Set as Completed,Ustaw jako ukończone,
+Set as Default,Ustaw jako domyślne,
+Set as Lost,Ustaw jako utracony,
+Set as Open,Ustaw jako otwarty,
+Set default inventory account for perpetual inventory,Ustaw domyślne konto zapasów dla zasobów reklamowych wieczystych,
+Set this if the customer is a Public Administration company.,"Ustaw to, jeśli klient jest firmą administracji publicznej.",
+Set {0} in asset category {1} or company {2},Ustaw {0} w kategorii aktywów {1} lub firmie {2},
+"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Ustawianie zdarzenia do {0}, ponieważ urzędnik dołączone do sprzedaży poniżej osób nie posiada identyfikator użytkownika {1}",
+Setting defaults,Ustawianie wartości domyślnych,
+Setting up Email,Konfiguracja e-mail,
+Setting up Email Account,Konfigurowanie konta e-mail,
+Setting up Employees,Ustawienia pracowników,
+Setting up Taxes,Konfigurowanie podatki,
+Setting up company,Zakładanie firmy,
+Settings,Ustawienia,
+"Settings for online shopping cart such as shipping rules, price list etc.","Ustawienia dla internetowego koszyka, takie jak zasady żeglugi, cennika itp",
+Settings for website homepage,Ustawienia strony głównej,
+Settings for website product listing,Ustawienia listy produktów w witrynie,
+Settled,Osiadły,
+Setup Gateway accounts.,Rachunki konfiguracji bramy.,
+Setup SMS gateway settings,Konfiguracja ustawień bramki SMS,
+Setup cheque dimensions for printing,Wymiary Sprawdź konfigurację do druku,
+Setup default values for POS Invoices,Ustaw wartości domyślne dla faktur POS,
+Setup mode of POS (Online / Offline),Tryb konfiguracji POS (Online / Offline),
+Setup your Institute in ERPNext,Skonfiguruj swój instytut w ERPNext,
+Share Balance,Udostępnij saldo,
+Share Ledger,Udostępnij Księgę,
+Share Management,Zarządzanie udziałami,
+Share Transfer,Udostępnij przelew,
+Share Type,Rodzaj udziału,
+Shareholder,Akcjonariusz,
+Ship To State,Ship To State,
+Shipments,Przesyłki,
+Shipping,Wysyłka,
+Shipping Address,Adres dostawy,
+"Shipping Address does not have country, which is required for this Shipping Rule","Adres wysyłki nie ma kraju, który jest wymagany dla tej reguły wysyłki",
+Shipping rule only applicable for Buying,Zasada wysyłki ma zastosowanie tylko do zakupów,
+Shipping rule only applicable for Selling,Reguła wysyłki dotyczy tylko sprzedaży,
+Shopify Supplier,Shopify dostawca,
+Shopping Cart,Koszyk,
+Shopping Cart Settings,Ustawienia koszyka,
+Short Name,Skrócona nazwa,
+Shortage Qty,Niedobór szt,
+Show Completed,Pokaż ukończone,
+Show Cumulative Amount,Pokaż łączną kwotę,
+Show Employee,Pokaż pracownika,
+Show Open,Pokaż otwarta,
+Show Opening Entries,Pokaż otwierające wpisy,
+Show Payment Details,Pokaż szczegóły płatności,
+Show Return Entries,Pokaż wpisy zwrotne,
+Show Salary Slip,Slip Pokaż Wynagrodzenie,
+Show Variant Attributes,Pokaż atrybuty wariantu,
+Show Variants,Pokaż warianty,
+Show closed,Pokaż closed,
+Show exploded view,Pokaż widok rozstrzelony,
+Show only POS,Pokaż tylko POS,
+Show unclosed fiscal year's P&L balances,Pokaż niezamkniętych rok obrotowy za P &amp; L sald,
+Show zero values,Pokaż wartości zerowe,
+Sick Leave,Urlop Chorobowy,
+Silt,Muł,
+Single Variant,Pojedynczy wariant,
+Single unit of an Item.,Jednostka produktu.,
+"Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}","Pomijanie Zostaw alokację dla następujących pracowników, ponieważ rekordy Urlop alokacji już istnieją przeciwko nim. {0}",
+"Skipping Salary Structure Assignment for the following employees, as Salary Structure Assignment records already exists against them. {0}","Pomijanie przydziału struktury wynagrodzeń dla następujących pracowników, ponieważ rekordy przypisania struktury wynagrodzeń już istnieją przeciwko nim. {0}",
+Slideshow,Pokaz slajdów,
+Slots for {0} are not added to the schedule,Gniazda dla {0} nie są dodawane do harmonogramu,
+Small,Mały,
+Soap & Detergent,Środki czystości i Detergenty,
+Software,Oprogramowanie,
+Software Developer,Programista,
+Softwares,Oprogramowania,
+Soil compositions do not add up to 100,Składy gleby nie sumują się do 100,
+Sold,Sprzedany,
+Some emails are invalid,Niektóre e-maile są nieprawidłowe,
+Some information is missing,Niektóre informacje brakuje,
+Something went wrong!,Coś poszło nie tak!,
+"Sorry, Serial Nos cannot be merged","Niestety, numery seryjne nie mogą zostać połączone",
+Source,Źródło,
+Source Name,Źródło Nazwa,
+Source Warehouse,Magazyn źródłowy,
+Source and Target Location cannot be same,Lokalizacja źródłowa i docelowa nie może być taka sama,
+Source and target warehouse cannot be same for row {0},Źródło i magazyn docelowy nie mogą być takie sama dla wiersza {0},
+Source and target warehouse must be different,Źródło i magazyn docelowy musi być inna,
+Source of Funds (Liabilities),Zobowiązania,
+Source warehouse is mandatory for row {0},Magazyn źródłowy jest obowiązkowy dla wiersza {0},
+Specified BOM {0} does not exist for Item {1},Określone BOM {0} nie istnieje dla pozycji {1},
+Split,Rozdzielać,
+Split Batch,Podział partii,
+Split Issue,Podziel problem,
+Sports,Sporty,
+Staffing Plan {0} already exist for designation {1},Plan zatrudnienia {0} już istnieje dla wyznaczenia {1},
+Standard,Standard,
+Standard Buying,Standardowe zakupy,
+Standard Selling,Standard sprzedaży,
+Standard contract terms for Sales or Purchase.,Standardowe warunki umowy sprzedaży lub kupna.,
+Start Date,Data startu,
+Start Date of Agreement can't be greater than or equal to End Date.,Data rozpoczęcia umowy nie może być większa lub równa dacie zakończenia.,
+Start Year,Rok rozpoczęcia,
+"Start and end dates not in a valid Payroll Period, cannot calculate {0}","Daty rozpoczęcia i zakończenia nie w ważnym okresie płacowym, nie można obliczyć {0}",
+"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Daty rozpoczęcia i zakończenia nie są w ważnym okresie rozliczeniowym, nie można obliczyć {0}.",
+Start date should be less than end date for Item {0},Data startu powinna być niższa od daty końca dla {0},
+Start date should be less than end date for task {0},Data rozpoczęcia powinna być mniejsza niż data zakończenia dla zadania {0},
+Start day is greater than end day in task '{0}',Dzień rozpoczęcia jest większy niż dzień zakończenia w zadaniu &quot;{0}&quot;,
+Start on,Zaczynaj na,
+State,Stan,
+State/UT Tax,Podatek stanowy / UT,
+Statement of Account,Wyciąg z rachunku,
+Status must be one of {0},Status musi być jednym z {0},
+Stock,Magazyn,
+Stock Adjustment,Korekta,
+Stock Analytics,Analityka magazynu,
+Stock Assets,Zapasy,
+Stock Available,Dostępność towaru,
+Stock Balance,Bilans zapasów,
+Stock Entries already created for Work Order ,Wpisy magazynowe już utworzone dla zlecenia pracy,
+Stock Entry,Zapis magazynowy,
+Stock Entry {0} created,Wpis {0} w Magazynie został utworzony,
+Stock Entry {0} is not submitted,Zdjęcie Wejście {0} nie jest składany,
+Stock Expenses,Wydatki magazynowe,
+Stock In Hand,Na stanie magazynu,
+Stock Items,produkty seryjne,
+Stock Ledger,Księga zapasów,
+Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Zapisy księgi zapasów oraz księgi głównej są odświeżone dla wybranego dokumentu zakupu,
+Stock Levels,Poziom zapasów,
+Stock Liabilities,Zadłużenie zapasów,
+Stock Options,Opcje magazynu,
+Stock Qty,Ilość zapasów,
+Stock Received But Not Billed,"Przyjęte na stan, nie zapłacone (zobowiązanie)",
+Stock Reports,Raporty seryjne,
+Stock Summary,Podsumowanie Zdjęcie,
+Stock Transactions,Operacje magazynowe,
+Stock UOM,Jednostka,
+Stock Value,Wartość zapasów,
+Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Saldo Zdjęcie w serii {0} będzie negatywna {1} dla pozycji {2} w hurtowni {3},
+Stock cannot be updated against Purchase Receipt {0},Zdjęcie nie może zostać zaktualizowany przed ZAKUPU {0},
+Stock cannot exist for Item {0} since has variants,"Zdjęcie nie może istnieć dla pozycji {0}, ponieważ ma warianty",
+Stock transactions before {0} are frozen,Operacje magazynowe przed {0} są zamrożone,
+Stop,Zatrzymaj,
+Stopped,Zatrzymany,
+"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Zatwierdzone zlecenie pracy nie może zostać anulowane, należy je najpierw anulować, aby anulować",
+Stores,Sklepy,
+Structures have been assigned successfully,Struktury zostały pomyślnie przypisane,
+Student,Student,
+Student Activity,Działalność uczniowska,
+Student Address,Adres studenta,
+Student Admissions,Rekrutacja dla studentów,
+Student Attendance,Obecność Studenta,
+"Student Batches help you track attendance, assessments and fees for students","Partie studenckich pomóc śledzenie obecności, oceny i opłat dla studentów",
+Student Email Address,Student adres email,
+Student Email ID,Student ID email,
+Student Group,Grupa Student,
+Student Group Strength,Siła grupy studentów,
+Student Group is already updated.,Grupa studentów jest już aktualizowana.,
+Student Group: ,Grupa studencka:,
+Student ID,legitymacja studencka,
+Student ID: ,Legitymacja studencka:,
+Student LMS Activity,Aktywność LMS studenta,
+Student Mobile No.,Nie Student Komórka,
+Student Name,Nazwa Student,
+Student Name: ,Imię ucznia:,
+Student Report Card,Karta zgłoszenia ucznia,
+Student is already enrolled.,Student jest już zarejestrowany.,
+Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} pojawia się wielokrotnie w wierszu {2} i {3},
+Student {0} does not belong to group {1},Student {0} nie należy do grupy {1},
+Student {0} exist against student applicant {1},Student {0} istnieć przed studenta wnioskodawcy {1},
+"Students are at the heart of the system, add all your students","Studenci są w samym sercu systemu, dodanie wszystkich swoich uczniów",
+Sub Assemblies,Komponenty,
+Sub Type,Podtyp,
+Sub-contracting,Podwykonawstwo,
+Subcontract,Zlecenie,
+Subject,Temat,
+Submit,Zatwierdź,
+Submit Proof,Prześlij dowód,
+Submit Salary Slip,Zatwierdź potrącenie z pensji,
+Submit this Work Order for further processing.,Prześlij to zlecenie pracy do dalszego przetwarzania.,
+Submit this to create the Employee record,"Prześlij to, aby utworzyć rekord pracownika",
+Submitting Salary Slips...,Przesyłanie wynagrodzeń ...,
+Subscription,Subskrypcja,
+Subscription Management,Zarządzanie subskrypcjami,
+Subscriptions,Subskrypcje,
+Subtotal,Razem,
+Successful,Udany,
+Successfully Reconciled,Pomyślnie uzgodnione,
+Successfully Set Supplier,Pomyślnie ustaw dostawcę,
+Successfully created payment entries,Pomyślnie utworzono wpisy płatności,
+Successfully deleted all transactions related to this company!,Pomyślnie usunięte wszystkie transakcje związane z tą firmą!,
+Sum of Scores of Assessment Criteria needs to be {0}.,Suma punktów kryteriów oceny musi być {0}.,
+Sum of points for all goals should be 100. It is {0},Suma punktów dla wszystkich celów powinno być 100. {0},
+Summary,Podsumowanie,
+Summary for this month and pending activities,Podsumowanie dla tego miesiąca i działań toczących,
+Summary for this week and pending activities,Podsumowanie na ten tydzień i działań toczących,
+Sunday,Niedziela,
+Suplier,Suplier,
+Supplier,Dostawca,
+Supplier Group,Grupa dostawców,
+Supplier Group master.,Mistrz grupy dostawców.,
+Supplier Id,ID Dostawcy,
+Supplier Invoice Date cannot be greater than Posting Date,Faktura dostawca Data nie może być większe niż Data publikacji,
+Supplier Invoice No,Nr faktury dostawcy,
+Supplier Invoice No exists in Purchase Invoice {0},Dostawca Faktura Nie istnieje faktura zakupu {0},
+Supplier Name,Nazwa dostawcy,
+Supplier Part No,Dostawca Część nr,
+Supplier Quotation,Oferta dostawcy,
+Supplier Scorecard,Karta wyników dostawcy,
+Supplier database.,Baza dostawców,
+Supplier {0} not found in {1},Dostawca {0} nie został znaleziony w {1},
+Supplier(s),Dostawca(y),
+Supplies made to UIN holders,Materiały dla posiadaczy UIN,
+Supplies made to Unregistered Persons,Dostawy dla niezarejestrowanych osób,
+Suppliies made to Composition Taxable Persons,Dodatki do osób podlegających opodatkowaniu,
+Supply Type,Rodzaj dostawy,
+Support,Wsparcie,
+Support Settings,Ustawienia wsparcia,
+Support Tickets,Bilety na wsparcie,
+Support queries from customers.,Zapytania klientów o wsparcie techniczne,
+Susceptible,Podatny,
+Sync has been temporarily disabled because maximum retries have been exceeded,"Synchronizacja została tymczasowo wyłączona, ponieważ przekroczono maksymalną liczbę ponownych prób",
+Syntax error in condition: {0},Błąd składni w warunku: {0},
+Syntax error in formula or condition: {0},Błąd składni we wzorze lub stanu: {0},
+System Manager,System Manager,
+TDS Rate %,Współczynnik TDS%,
+Tap items to add them here,"Dotknij elementów, aby je dodać tutaj",
+Target,Cel,
+Target ({}),Cel ({}),
+Target Warehouse,Magazyn docelowy,
+Target warehouse is mandatory for row {0},Magazyn docelowy jest obowiązkowy dla wiersza {0},
+Task,Zadanie,
+Tasks,Zadania,
+Tasks have been created for managing the {0} disease (on row {1}),Utworzono zadania do zarządzania chorobą {0} (w wierszu {1}),
+Tax,Podatek,
+Tax Assets,Podatek należny (zwrot),
+Tax Category,Kategoria podatku,
+Tax Category for overriding tax rates.,Kategoria podatkowa za nadrzędne stawki podatkowe.,
+"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Kategoria podatkowa została zmieniona na &quot;Razem&quot;, ponieważ wszystkie elementy są towarami nieruchoma",
+Tax ID,Numer identyfikacji podatkowej (NIP),
+Tax Id: ,Identyfikator podatkowy:,
+Tax Rate,Stawka podatku,
+Tax Rule Conflicts with {0},Konflikty przepisu podatkowego z {0},
+Tax Rule for transactions.,Reguła podatkowa dla transakcji.,
+Tax Template is mandatory.,Szablon podatków jest obowiązkowy.,
+Tax Withholding rates to be applied on transactions.,Stawki podatku u źródła stosowane do transakcji.,
+Tax template for buying transactions.,Szablon podatków dla transakcji zakupu.,
+Tax template for item tax rates.,Szablon podatku dla stawek podatku od towarów.,
+Tax template for selling transactions.,Szablon podatków dla transakcji sprzedaży.,
+Taxable Amount,Kwota podlegająca opodatkowaniu,
+Taxes,Podatki,
+Team Updates,Aktualizacje zespół,
+Technology,Technologia,
+Telecommunications,Telekomunikacja,
+Telephone Expenses,Wydatki telefoniczne,
+Television,Telewizja,
+Template Name,Nazwa szablonu,
+Template of terms or contract.,Szablon z warunkami lub umową.,
+Templates of supplier scorecard criteria.,Szablony kryteriów oceny dostawców.,
+Templates of supplier scorecard variables.,Szablony dostawców zmiennych.,
+Templates of supplier standings.,Szablony standings dostawców.,
+Temporarily on Hold,Chwilowo zawieszone,
+Temporary,Tymczasowy,
+Temporary Accounts,Rachunki tymczasowe,
+Temporary Opening,Tymczasowe otwarcia,
+Terms and Conditions,Regulamin,
+Terms and Conditions Template,Szablony warunków i regulaminów,
+Territory,Region,
+Test,Test,
+Thank you,Dziękuję,
+Thank you for your business!,Dziękuję dla Twojej firmy!,
+The 'From Package No.' field must neither be empty nor it's value less than 1.,The &#39;From Package No.&#39; pole nie może być puste ani jego wartość mniejsza niż 1.,
+The Brand,Marka,
+The Item {0} cannot have Batch,Element {0} nie może mieć Batch,
+The Loyalty Program isn't valid for the selected company,Program lojalnościowy nie jest ważny dla wybranej firmy,
+The Payment Term at row {0} is possibly a duplicate.,Termin płatności w wierszu {0} jest prawdopodobnie duplikatem.,
+The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Termin Data zakończenia nie może być wcześniejsza niż data początkowa Term. Popraw daty i spróbuj ponownie.,
+The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Termin Data zakończenia nie może być późniejsza niż data zakończenia roku na rok akademicki, którego termin jest związany (Academic Year {}). Popraw daty i spróbuj ponownie.",
+The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Termin Data rozpoczęcia nie może być krótszy niż rok od daty rozpoczęcia roku akademickiego, w jakim termin ten jest powiązany (Academic Year {}). Popraw daty i spróbuj ponownie.",
+The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Rok Data zakończenia nie może być wcześniejsza niż data początkowa rok. Popraw daty i spróbuj ponownie.,
+The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,"Kwota {0} ustawiona w tym żądaniu płatności różni się od obliczonej kwoty wszystkich planów płatności: {1}. Upewnij się, że jest to poprawne przed wysłaniem dokumentu.",
+The day(s) on which you are applying for leave are holidays. You need not apply for leave.,"Dzień (s), w którym starasz się o urlop jest święta. Nie musisz ubiegać się o urlop.",
+The field From Shareholder cannot be blank,Pole Od Akcjonariusza nie może być puste,
+The field To Shareholder cannot be blank,Pole Do akcjonariusza nie może być puste,
+The fields From Shareholder and To Shareholder cannot be blank,Pola Od Akcjonariusza i Do Akcjonariusza nie mogą być puste,
+The folio numbers are not matching,Numery folio nie pasują do siebie,
+The holiday on {0} is not between From Date and To Date,Święto w dniu {0} nie jest pomiędzy Od Data i do tej pory,
+The name of the institute for which you are setting up this system.,"Nazwa instytutu, dla którego jest utworzenie tego systemu.",
+The name of your company for which you are setting up this system.,Nazwa firmy / organizacji dla której uruchamiasz niniejszy system.,
+The number of shares and the share numbers are inconsistent,Liczba akcji i liczby akcji są niespójne,
+The payment gateway account in plan {0} is different from the payment gateway account in this payment request,Rachunek bramy płatniczej w planie {0} różni się od konta bramy płatności w tym żądaniu płatności,
+The selected BOMs are not for the same item,Wybrane LM nie są na tej samej pozycji,
+The selected item cannot have Batch,Wybrany element nie może mieć Batch,
+The seller and the buyer cannot be the same,Sprzedawca i kupujący nie mogą być tacy sami,
+The shareholder does not belong to this company,Akcjonariusz nie należy do tej spółki,
+The shares already exist,Akcje już istnieją,
+The shares don't exist with the {0},Akcje nie istnieją z {0},
+"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Zadanie zostało zakolejkowane jako zadanie w tle. W przypadku jakichkolwiek problemów z przetwarzaniem w tle, system doda komentarz dotyczący błędu w tym uzgadnianiu i powróci do etapu wersji roboczej",
+"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Następnie wycena Zasady są filtrowane na podstawie Klienta, grupy klientów, Terytorium, dostawcy, dostawca, typu kampanii, Partner Sales itp",
+"There are inconsistencies between the rate, no of shares and the amount calculated","Występują niespójności między stopą, liczbą akcji i obliczoną kwotą",
+There are more holidays than working days this month.,Jest więcej świąt niż dni pracujących,
+There can be multiple tiered collection factor based on the total spent. But the conversion factor for redemption will always be same for all the tier.,Może istnieć wiele warstwowych współczynników zbierania w oparciu o całkowitą ilość wydanych pieniędzy. Jednak współczynnik konwersji dla umorzenia będzie zawsze taki sam dla wszystkich poziomów.,
+There can only be 1 Account per Company in {0} {1},Nie może być tylko jedno konto na Spółkę w {0} {1},
+"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Może być tylko jedna Zasada dostawy z wartością 0 lub pustą wartością w polu ""Wartość""",
+There is no leave period in between {0} and {1},Nie ma okresu próbnego między {0} a {1},
+There is nothing to edit.,Nie ma nic do edycji,
+There isn't any item variant for the selected item,Nie ma żadnego wariantu przedmiotu dla wybranego przedmiotu,
+"There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.","Wygląda na to, że problem dotyczy konfiguracji serwera GoCardless. Nie martw się, w przypadku niepowodzenia kwota zostanie zwrócona na Twoje konto.",
+There were errors creating Course Schedule,Podczas tworzenia harmonogramu kursów wystąpiły błędy,
+There were errors.,Wystąpiły błędy,
+This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"Pozycja ta jest szablon i nie mogą być wykorzystywane w transakcjach. Atrybuty pozycji zostaną skopiowane nad do wariantów chyba ""Nie Kopiuj"" jest ustawiony",
+This Item is a Variant of {0} (Template).,Ta pozycja jest wariantem {0} (szablon).,
+This Month's Summary,Podsumowanie tego miesiąca,
+This Week's Summary,Podsumowanie W tym tygodniu,
+This action will stop future billing. Are you sure you want to cancel this subscription?,Ta czynność zatrzyma przyszłe płatności. Czy na pewno chcesz anulować subskrypcję?,
+This covers all scorecards tied to this Setup,Obejmuje to wszystkie karty wyników powiązane z niniejszą kartą,
+This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Niniejszy dokument ma na granicy przez {0} {1} dla pozycji {4}. Robisz kolejny {3} przeciwko samo {2}?,
+This is a root account and cannot be edited.,To jest konto root i nie może być edytowane.,
+This is a root customer group and cannot be edited.,To jest grupa klientów root i nie mogą być edytowane.,
+This is a root department and cannot be edited.,To jest dział główny i nie można go edytować.,
+This is a root healthcare service unit and cannot be edited.,To jest podstawowa jednostka opieki zdrowotnej i nie można jej edytować.,
+This is a root item group and cannot be edited.,To jest grupa przedmiotów root i nie mogą być edytowane.,
+This is a root sales person and cannot be edited.,To jest sprzedawca root i nie może być edytowany.,
+This is a root supplier group and cannot be edited.,To jest główna grupa dostawców i nie można jej edytować.,
+This is a root territory and cannot be edited.,To jest obszar root i nie może być edytowany.,
+This is an example website auto-generated from ERPNext,Ta przykładowa strona została automatycznie wygenerowana przez ERPNext,
+This is based on logs against this Vehicle. See timeline below for details,Opiera się to na dzienniki przeciwko tego pojazdu. Zobacz harmonogram poniżej w szczegółach,
+This is based on stock movement. See {0} for details,Jest to oparte na ruchu zapasów. Zobacz {0} o szczegóły,
+This is based on the Time Sheets created against this project,Jest to oparte na kartach czasu pracy stworzonych wobec tego projektu,
+This is based on the attendance of this Employee,Jest to oparte na obecności pracownika,
+This is based on the attendance of this Student,Jest to oparte na obecności tego Studenta,
+This is based on transactions against this Customer. See timeline below for details,"Wykres oparty na operacjach związanych z klientem. Sprawdź poniżej oś czasu, aby uzyskać więcej szczegółów.",
+This is based on transactions against this Healthcare Practitioner.,Jest to oparte na transakcjach przeciwko temu pracownikowi opieki zdrowotnej.,
+This is based on transactions against this Patient. See timeline below for details,"Opiera się to na transakcjach przeciwko temu pacjentowi. Zobacz poniżej linię czasu, aby uzyskać szczegółowe informacje",
+This is based on transactions against this Sales Person. See timeline below for details,"Jest to oparte na transakcjach z tą osobą handlową. Zobacz oś czasu poniżej, aby uzyskać szczegółowe informacje",
+This is based on transactions against this Supplier. See timeline below for details,"Wykres oparty na operacjach związanych z dostawcą. Sprawdź poniżej oś czasu, aby uzyskać więcej szczegółów.",
+This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Spowoduje to wysłanie Salary Slips i utworzenie wpisu księgowego. Czy chcesz kontynuować?,
+This {0} conflicts with {1} for {2} {3},Ten {0} konflikty z {1} do {2} {3},
+Time Sheet for manufacturing.,Arkusz Czas produkcji.,
+Time Tracking,time Tracking,
+"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Przesunięcie przedziału czasowego, przedział od {0} do {1} pokrywa się z istniejącym bokiem {2} do {3}",
+Time slots added,Dodano gniazda czasowe,
+Time(in mins),Czas (w minutach),
+Timer,Regulator czasowy,
+Timer exceeded the given hours.,Minutnik przekroczył podane godziny.,
+Timesheet,Lista obecności,
+Timesheet for tasks.,Grafiku zadań.,
+Timesheet {0} is already completed or cancelled,Grafiku {0} jest już zakończone lub anulowane,
+Timesheets,Ewidencja czasu pracy,
+"Timesheets help keep track of time, cost and billing for activites done by your team","Ewidencja czasu pomaga śledzić czasu, kosztów i rozliczeń dla aktywnosci przeprowadzonych przez zespół",
+Titles for print templates e.g. Proforma Invoice.,Tytuł szablonu wydruku np.: Faktura Proforma,
+To,Do,
+To Address 1,Aby Adres 1,
+To Address 2,Do adresu 2,
+To Bill,Wystaw rachunek,
+To Date,Do daty,
+To Date cannot be before From Date,"""Do daty"" nie może być terminem przed ""od daty""",
+To Date cannot be less than From Date,Data nie może być mniejsza niż Od daty,
+To Date must be greater than From Date,To Date musi być większe niż From Date,
+To Date should be within the Fiscal Year. Assuming To Date = {0},Aby Data powinna być w tym roku podatkowym. Zakładając To Date = {0},
+To Datetime,Aby DateTime,
+To Deliver,Dostarczyć,
+To Deliver and Bill,Do dostarczenia i Bill,
+To Fiscal Year,Do roku podatkowego,
+To GSTIN,Do GSTIN,
+To Party Name,Nazwa drużyny,
+To Pin Code,Aby przypiąć kod,
+To Place,Do miejsca,
+To Receive,Otrzymać,
+To Receive and Bill,Do odbierania i Bill,
+To State,Określić,
+To Warehouse,Do magazynu,
+To create a Payment Request reference document is required,"Aby utworzyć dokument referencyjny żądania zapłaty, wymagane jest",
+To date can not be equal or less than from date,Do tej pory nie może być równa lub mniejsza niż od daty,
+To date can not be less than from date,Do tej pory nie może być mniejsza niż od daty,
+To date can not greater than employee's relieving date,Do tej pory nie może przekroczyć daty zwolnienia pracownika,
+"To filter based on Party, select Party Type first","Aby filtrować na podstawie partii, wybierz Party Wpisz pierwsze",
+"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Aby uzyskać najlepsze z ERPNext, zalecamy, aby poświęcić trochę czasu i oglądać te filmy pomoc.",
+To make Customer based incentive schemes.,Aby tworzyć systemy motywacyjne oparte na Kliencie.,
+"To merge, following properties must be same for both items","Aby scalić, poniższe właściwości muszą być takie same dla obu przedmiotów",
+"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Cennik nie stosuje regułę w danej transakcji, wszystkie obowiązujące przepisy dotyczące cen powinny być wyłączone.",
+"To set this Fiscal Year as Default, click on 'Set as Default'","Aby ustawić ten rok finansowy jako domyślny, kliknij przycisk ""Ustaw jako domyślne""",
+To view logs of Loyalty Points assigned to a Customer.,Aby wyświetlić logi punktów lojalnościowych przypisanych do klienta.,
+To {0},Do {0},
+To {0} | {1} {2},Do {0} | {1} {2},
+Toggle Filters,Przełącz filtry,
+Too many columns. Export the report and print it using a spreadsheet application.,Zbyt wiele kolumn. Wyeksportować raport i wydrukować go za pomocą arkusza kalkulacyjnego.,
+Tools,Narzędzia,
+Total (Credit),Razem (Credit),
+Total (Without Tax),Razem (bez podatku),
+Total Absent,Razem Nieobecny,
+Total Achieved,Razem Osiągnięte,
+Total Actual,Razem Rzeczywisty,
+Total Allocated Leaves,Całkowicie Przydzielone Nieobecności,
+Total Amount,Wartość całkowita,
+Total Amount Credited,Całkowita kwota kredytu,
+Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Wszystkich obowiązujących opłat w ZAKUPU Elementy tabeli muszą być takie same jak Wszystkich podatkach i opłatach,
+Total Budget,Cały budżet,
+Total Collected: {0},Łącznie zbierane: {0},
+Total Commission,Całkowita kwota prowizji,
+Total Contribution Amount: {0},Łączna kwota dotacji: {0},
+Total Credit/ Debit Amount should be same as linked Journal Entry,"Całkowita kwota kredytu / debetu powinna być taka sama, jak połączona pozycja księgowa",
+Total Debit must be equal to Total Credit. The difference is {0},Całkowita kwota po stronie debetowej powinna być równa całkowitej kwocie po stronie kretytowej. Różnica wynosi {0},
+Total Deduction,Całkowita kwota odliczenia,
+Total Invoiced Amount,Całkowita zafakturowana kwota,
+Total Leaves,Wszystkich Nieobecności,
+Total Order Considered,Zamówienie razem Uważany,
+Total Order Value,Łączna wartość zamówienia,
+Total Outgoing,Razem Wychodzące,
+Total Outstanding,Total Outstanding,
+Total Outstanding Amount,Łączna kwota,
+Total Outstanding: {0},Całkowity stan: {0},
+Total Paid Amount,Kwota całkowita Płatny,
+Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Całkowita kwota płatności w harmonogramie płatności musi być równa sumie całkowitej / zaokrąglonej,
+Total Payments,Płatności ogółem,
+Total Present,Razem Present,
+Total Qty,Razem szt,
+Total Quantity,Całkowita ilość,
+Total Revenue,Całkowita wartość dochodu,
+Total Student,Total Student,
+Total Target,Łączna docelowa,
+Total Tax,Razem podatkowa,
+Total Taxable Amount,Całkowita kwota podlegająca opodatkowaniu,
+Total Taxable Value,Całkowita wartość podlegająca opodatkowaniu,
+Total Unpaid: {0},Razem Niepłatny: {0},
+Total Variance,Całkowitej wariancji,
+Total Weightage of all Assessment Criteria must be 100%,Razem weightage wszystkich kryteriów oceny muszą być w 100%,
+Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Suma zaliczki ({0}) przed zamówieniem {1} nie może być większa od ogólnej sumy ({2}),
+Total advance amount cannot be greater than total claimed amount,Całkowita kwota zaliczki nie może być większa niż całkowita kwota roszczenia,
+Total advance amount cannot be greater than total sanctioned amount,Całkowita kwota zaliczki nie może być większa niż całkowita kwota sankcjonowana,
+Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,Całkowita liczba przydzielonych urlopów to więcej dni niż maksymalny przydział {0} typu urlopu dla pracownika {1} w danym okresie,
+Total allocated leaves are more than days in the period,Liczba przyznanych zwolnień od pracy jest większa niż dni w okresie,
+Total allocated percentage for sales team should be 100,Łącznie przydzielony procent sprzedaży dla zespołu powinien wynosić 100,
+Total cannot be zero,Razem nie może być wartością zero,
+Total contribution percentage should be equal to 100,Całkowity procent wkładu powinien być równy 100,
+Total flexible benefit component amount {0} should not be less than max benefits {1},Całkowita kwota elastycznego składnika świadczeń {0} nie powinna być mniejsza niż maksymalna korzyść {1},
+Total hours: {0},Całkowita liczba godzin: {0},
+Total leaves allocated is mandatory for Leave Type {0},Całkowita liczba przydzielonych Nieobecności jest obowiązkowa dla Typu Urlopu {0},
+Total working hours should not be greater than max working hours {0},Całkowita liczba godzin pracy nie powinna być większa niż max godzinach pracy {0},
+Total {0} ({1}),Razem {0} ({1}),
+"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Razem {0} dla wszystkich elementów wynosi zero, może trzeba zmienić „Dystrybucja opłat na podstawie”",
+Total(Amt),Razem (Amt),
+Total(Qty),Razem (szt),
+Traceability,Śledzenie,
+Traceback,Traceback,
+Track Leads by Lead Source.,Śledzenie potencjalnych klientów przez źródło potencjalnych klientów.,
+Training,Trening,
+Training Event,Training Event,
+Training Events,Wydarzenia szkoleniowe,
+Training Feedback,Szkolenie Zgłoszenie,
+Training Result,Wynik treningowe,
+Transaction,Transakcja,
+Transaction Date,Data transakcji,
+Transaction Type,typ transakcji,
+Transaction currency must be same as Payment Gateway currency,"Waluta transakcji musi być taka sama, jak waluta wybranej płatności",
+Transaction not allowed against stopped Work Order {0},Transakcja nie jest dozwolona w przypadku zatrzymanego zlecenia pracy {0},
+Transaction reference no {0} dated {1},Transakcja ma odniesienia {0} z {1},
+Transactions,Transakcje,
+Transactions can only be deleted by the creator of the Company,Transakcje mogą być usunięte tylko przez twórcę Spółki,
+Transfer,Transfer,
+Transfer Material,Transfer materiału,
+Transfer Type,Rodzaj transferu,
+Transfer an asset from one warehouse to another,Przeniesienie aktywów z jednego magazynu do drugiego,
+Transfered,Przeniesione,
+Transferred Quantity,Przeniesiona ilość,
+Transport Receipt Date,Transport Data odbioru,
+Transport Receipt No,Nr odbioru transportu,
+Transportation,Transport,
+Transporter ID,Identyfikator transportera,
+Transporter Name,Nazwa przewoźnika,
+Travel,Podróż,
+Travel Expenses,Wydatki na podróże,
+Tree Type,Typ drzewa,
+Tree of Bill of Materials,Drzewo Zestawienia materiałów,
+Tree of Item Groups.,Drzewo grupy produktów,
+Tree of Procedures,Drzewo procedur,
+Tree of Quality Procedures.,Drzewo procedur jakości.,
+Tree of financial Cost Centers.,Drzewo MPK finansowych.,
+Tree of financial accounts.,Drzewo kont finansowych.,
+Treshold {0}% appears more than once,Próg {0}% występuje więcej niż jeden raz,
+Trial Period End Date Cannot be before Trial Period Start Date,Termin zakończenia okresu próbnego Nie może być przed datą rozpoczęcia okresu próbnego,
+Trialling,Trialling,
+Type of Business,Rodzaj biznesu,
+Types of activities for Time Logs,Rodzaje działalności za czas Logi,
+UOM,Jednostka miary,
+UOM Conversion factor is required in row {0},Współczynnik konwersji jednostki miary jest wymagany w rzędzie {0},
+UOM coversion factor required for UOM: {0} in Item: {1},Współczynnik konwersji jednostki miary jest wymagany dla jednostki miary: {0} w Przedmiocie: {1},
+URL,URL,
+Unable to find DocType {0},Nie można znaleźć DocType {0},
+Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Nie można znaleźć kursu wymiany dla {0} do {1} dla daty klucza {2}. Proszę utworzyć ręcznie rekord wymiany walut,
+Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,"Nie można znaleźć wyników, począwszy od {0}. Musisz mieć stały wynik od 0 do 100",
+Unable to find variable: ,Nie można znaleźć zmiennej:,
+Unblock Invoice,Odblokuj fakturę,
+Uncheck all,Odznacz wszystkie,
+Unclosed Fiscal Years Profit / Loss (Credit),Unclosed fiskalna Lata Zysk / Strata (Credit),
+Unit,szt.,
+Unit of Measure,Jednostka miary,
+Unit of Measure {0} has been entered more than once in Conversion Factor Table,Jednostka miary {0} została wprowadzona więcej niż raz w Tabelce Współczynnika Konwersji,
+Unknown,Nieznany,
+Unpaid,Niezapłacone,
+Unsecured Loans,Pożyczki bez pokrycia,
+Unsubscribe from this Email Digest,Wypisać się z tej Email Digest,
+Unsubscribed,Nie zarejestrowany,
+Until,Do,
+Unverified Webhook Data,Niezweryfikowane dane z Webhook,
+Update Account Name / Number,Zaktualizuj nazwę / numer konta,
+Update Account Number / Name,Zaktualizuj numer / nazwę konta,
+Update Cost,Zaktualizuj koszt,
+Update Items,Aktualizuj elementy,
+Update Print Format,Aktualizacja Format wydruku,
+Update Response,Zaktualizuj odpowiedź,
+Update bank payment dates with journals.,Aktualizacja terminów płatności banowych,
+Update in progress. It might take a while.,Aktualizacja w toku. To może trochę potrwać.,
+Update rate as per last purchase,Zaktualizuj stawkę za ostatni zakup,
+Update stock must be enable for the purchase invoice {0},Aktualizuj zapasy musi być włączone dla faktury zakupu {0},
+Updating Variants...,Aktualizowanie wariantów ...,
+Upload your letter head and logo. (you can edit them later).,Prześlij nagłówek firmowy i logo. (Można je edytować później).,
+Upper Income,Wzrost Wpływów,
+Use Sandbox,Korzystanie Sandbox,
+Used Leaves,Wykorzystane Nieobecności,
+User,Użytkownik,
+User ID,ID Użytkownika,
+User ID not set for Employee {0},ID Użytkownika nie ustawiony dla Pracownika {0},
+User Remark,Nota Użytkownika,
+User has not applied rule on the invoice {0},Użytkownik nie zastosował reguły na fakturze {0},
+User {0} already exists,Użytkownik {0} już istnieje,
+User {0} created,Utworzono użytkownika {0},
+User {0} does not exist,Użytkownik {0} nie istnieje,
+User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Użytkownik {0} nie ma żadnego domyślnego profilu POS. Sprawdź domyślne w wierszu {1} dla tego użytkownika.,
+User {0} is already assigned to Employee {1},Użytkownik {0} jest już przyporządkowany do Pracownika {1},
+User {0} is already assigned to Healthcare Practitioner {1},Użytkownik {0} jest już przypisany do pracownika służby zdrowia {1},
+Users,Użytkownicy,
+Utility Expenses,Wydatki na usługi komunalne,
+Valid From Date must be lesser than Valid Upto Date.,Ważny od daty musi być mniejszy niż ważna data w górę.,
+Valid Till,Obowiązuje do dnia,
+Valid from and valid upto fields are mandatory for the cumulative,Obowiązujące od i prawidłowe pola upto są obowiązkowe dla skumulowanego,
+Valid from date must be less than valid upto date,Ważny od daty musi być krótszy niż data ważności,
+Valid till date cannot be before transaction date,Data ważności nie może być poprzedzona datą transakcji,
+Validity,Ważność,
+Validity period of this quotation has ended.,Okres ważności tej oferty zakończył się.,
+Valuation Rate,Wskaźnik wyceny,
+Valuation Rate is mandatory if Opening Stock entered,"Wycena Cena jest obowiązkowe, jeżeli wprowadzone Otwarcie Zdjęcie",
+Valuation type charges can not marked as Inclusive,Opłaty typu Wycena nie oznaczone jako Inclusive,
+Value Or Qty,Wartość albo Ilość,
+Value Proposition,Propozycja wartości,
+Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Wartość atrybutu {0} musi mieścić się w przedziale {1} z {2} w przyrostach {3} {4} Przedmiot,
+Value missing,Wartość brakująca,
+Value must be between {0} and {1},Wartość musi zawierać się między {0} a {1},
+"Values of exempt, nil rated and non-GST inward supplies","Wartości zwolnionych, zerowych i niezawierających GST dostaw wewnętrznych",
+Variable,Zmienna,
+Variance,Zmienność,
+Variance ({}),Wariancja ({}),
+Variant,Wariant,
+Variant Attributes,Variant Atrybuty,
+Variant Based On cannot be changed,Variant Based On nie może zostać zmieniony,
+Variant Details Report,Szczegółowy raport dotyczący wariantu,
+Variant creation has been queued.,Tworzenie wariantu zostało umieszczone w kolejce.,
+Vehicle Expenses,Wydatki Samochodowe,
+Vehicle No,Nr pojazdu,
+Vehicle Type,Typ pojazdu,
+Vehicle/Bus Number,Numer pojazdu / autobusu,
+Venture Capital,Kapitał wysokiego ryzyka,
+View Chart of Accounts,Zobacz plan kont,
+View Fees Records,Zobacz rekord opłat,
+View Form,Wyświetl formularz,
+View Lab Tests,Wyświetl testy laboratoryjne,
+View Leads,Zobacz Tropy,
+View Ledger,Podgląd księgi,
+View Now,Zobacz teraz,
+View a list of all the help videos,Zobacz listę wszystkich filmów pomocy,
+View in Cart,Zobacz Koszyk,
+Visit report for maintenance call.,Raport wizyty dla wezwania konserwacji.,
+Visit the forums,Odwiedź fora,
+Vital Signs,Oznaki życia,
+Volunteer,Wolontariusz,
+Volunteer Type information.,Informacje o typie wolontariusza.,
+Volunteer information.,Informacje o wolontariuszu.,
+Voucher #,Bon #,
+Voucher No,Nr Podstawy księgowania,
+Voucher Type,Typ Podstawy,
+WIP Warehouse,WIP Magazyn,
+Walk In,Wejście,
+Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Magazyn nie może być skasowany tak długo jak długo istnieją zapisy w księdze stanu dla tego magazynu.,
+Warehouse cannot be changed for Serial No.,Magazyn nie może być zmieniony dla Nr Seryjnego,
+Warehouse is mandatory,Magazyn jest obowiązkowe,
+Warehouse is mandatory for stock Item {0} in row {1},Magazyn jest obowiązkowy dla Przedmiotu {0} w rzędzie {1},
+Warehouse not found in the system,Magazyn nie został znaleziony w systemie,
+"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}","Wymagany magazyn w Wiersz nr {0}, ustaw domyślny magazyn dla pozycji {1} dla firmy {2}",
+Warehouse required for stock Item {0},Magazyn wymagany dla przedmiotu {0},
+Warehouse {0} can not be deleted as quantity exists for Item {1},Magazyn {0} nie może zostać usunięty ponieważ istnieje wartość dla przedmiotu {1},
+Warehouse {0} does not belong to company {1},Magazyn {0} nie należy do firmy {1},
+Warehouse {0} does not exist,Magazyn {0} nie istnieje,
+"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Magazyn {0} nie jest powiązany z jakimikolwiek kontem, wspomnij o tym w raporcie magazynu lub ustaw domyślnego konta zapasowego w firmie {1}.",
+Warehouses with child nodes cannot be converted to ledger,Magazyny z węzłów potomnych nie mogą być zamieniane na Ledger,
+Warehouses with existing transaction can not be converted to group.,Magazyny z istniejącymi transakcji nie mogą być zamieniane na grupy.,
+Warehouses with existing transaction can not be converted to ledger.,Magazyny z istniejącymi transakcji nie mogą być konwertowane do księgi głównej.,
+Warning,Ostrzeżenie,
+Warning: Another {0} # {1} exists against stock entry {2},Ostrzeżenie: Inny {0} # {1} istnieje we wpisie asortymentu {2},
+Warning: Invalid SSL certificate on attachment {0},Ostrzeżenie: Nieprawidłowy certyfikat SSL w załączniku {0},
+Warning: Invalid attachment {0},Warning: Invalid Załącznik {0},
+Warning: Leave application contains following block dates,Ostrzeżenie: Aplikacja o urlop zawiera następujące zablokowane daty,
+Warning: Material Requested Qty is less than Minimum Order Qty,Ostrzeżenie: Ilość Zapotrzebowanego Materiału jest mniejsza niż minimalna ilość na zamówieniu,
+Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Ostrzeżenie: Zamówienie sprzedaży {0} już istnieje wobec Klienta Zamówienia {1},
+Warranty,Gwarancja,
+Warranty Claim,Roszczenie gwarancyjne,
+Warranty Claim against Serial No.,Roszczenie gwarancyjne z numerem seryjnym,
+Website,Strona WWW,
+Website Image should be a public file or website URL,Strona Obraz powinien być plik publiczny lub adres witryny,
+Website Image {0} attached to Item {1} cannot be found,Strona Obraz {0} dołączone do pozycji {1} nie można znaleźć,
+Website Listing,Listing Witryny,
+Website Manager,Manager strony WWW,
+Website Settings,Ustawienia witryny,
+Wednesday,Środa,
+Week,Tydzień,
+Weekdays,Dni robocze,
+Weekly,Tygodniowo,
+"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Waga jest określona, \n Ustaw także ""Wagę jednostkową""",
+Welcome email sent,E-mail z powitaniem został wysłany,
+Welcome to ERPNext,Zapraszamy do ERPNext,
+What do you need help with?,Z czym potrzebujesz pomocy?,
+What does it do?,Czym się zajmuje?,
+Where manufacturing operations are carried.,"W przypadku, gdy czynności wytwórcze są prowadzone.",
+White,Biały,
+Wire Transfer,Przelew,
+WooCommerce Products,Produkty WooCommerce,
+Work In Progress,Produkty w toku,
+Work Order,Porządek pracy,
+Work Order already created for all items with BOM,Zamówienie pracy zostało już utworzone dla wszystkich produktów z zestawieniem komponentów,
+Work Order cannot be raised against a Item Template,Zlecenie pracy nie może zostać podniesione na podstawie szablonu przedmiotu,
+Work Order has been {0},Zamówienie pracy zostało {0},
+Work Order not created,Zamówienie pracy nie zostało utworzone,
+Work Order {0} must be cancelled before cancelling this Sales Order,Zamówienie pracy {0} musi zostać anulowane przed anulowaniem tego zamówienia sprzedaży,
+Work Order {0} must be submitted,Zamówienie pracy {0} musi zostać przesłane,
+Work Orders Created: {0},Utworzono zlecenia pracy: {0},
+Work Summary for {0},Podsumowanie pracy dla {0},
+Work-in-Progress Warehouse is required before Submit,Magazyn z produkcją w toku jest wymagany przed wysłaniem,
+Workflow,Przepływ pracy (Workflow),
+Working,Pracuje,
+Working Hours,Godziny pracy,
+Workstation,Stacja robocza,
+Workstation is closed on the following dates as per Holiday List: {0},Stacja robocza jest zamknięta w następujących terminach wg listy wakacje: {0},
+Wrapping up,Zawijanie,
+Wrong Password,Niepoprawne hasło,
+Year start date or end date is overlapping with {0}. To avoid please set company,data rozpoczęcia roku lub data końca pokrywa się z {0}. Aby uniknąć należy ustawić firmę,
+You are not authorized to add or update entries before {0},Nie masz uprawnień aby zmieniać lub dodawać elementy przed {0},
+You are not authorized to approve leaves on Block Dates,Nie masz uprawnień do zatwierdzania tych urlopów,
+You are not authorized to set Frozen value,Nie masz uprawnień do ustawienia zamrożenej wartości,
+You are not present all day(s) between compensatory leave request days,Nie jesteś obecny przez cały dzień (dni) między dniami prośby o urlop wyrównawczy,
+You can not change rate if BOM mentioned agianst any item,Nie możesz zmienić danych jeśli BOM jest przeciw jakiejkolwiek rzeczy,
+You can not enter current voucher in 'Against Journal Entry' column,You can not enter current voucher in 'Against Journal Entry' column,
+You can only have Plans with the same billing cycle in a Subscription,Możesz mieć tylko Plany z tym samym cyklem rozliczeniowym w Subskrypcji,
+You can only redeem max {0} points in this order.,Możesz maksymalnie wykorzystać maksymalnie {0} punktów w tej kolejności.,
+You can only renew if your membership expires within 30 days,Przedłużenie członkostwa można odnowić w ciągu 30 dni,
+You can only select a maximum of one option from the list of check boxes.,Możesz wybrać maksymalnie jedną opcję z listy pól wyboru.,
+You can only submit Leave Encashment for a valid encashment amount,Możesz przesłać tylko opcję Leave Encashment dla prawidłowej kwoty depozytu,
+You can't redeem Loyalty Points having more value than the Grand Total.,Nie możesz wymienić punktów lojalnościowych o większej wartości niż suma ogólna.,
+You cannot credit and debit same account at the same time,Nie można wykonywać zapisów po stronie debetowej oraz kredytowej tego samego konta w jednym czasie,
+You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Nie można usunąć Fiscal Year {0}. Rok fiskalny {0} jest ustawiona jako domyślna w Ustawienia globalne,
+You cannot delete Project Type 'External',Nie można usunąć typu projektu &quot;zewnętrzny&quot;,
+You cannot edit root node.,Nie można edytować węzła głównego.,
+You cannot restart a Subscription that is not cancelled.,"Nie można ponownie uruchomić subskrypcji, która nie zostanie anulowana.",
+You don't have enought Loyalty Points to redeem,"Nie masz wystarczającej liczby Punktów Lojalnościowych, aby je wykorzystać",
+You have already assessed for the assessment criteria {}.,Oceniałeś już kryteria oceny {}.,
+You have already selected items from {0} {1},Już wybrane pozycje z {0} {1},
+You have been invited to collaborate on the project: {0},Zostałeś zaproszony do współpracy przy projekcie: {0},
+You have entered duplicate items. Please rectify and try again.,Wprowadziłeś duplikat istniejących rzeczy. Sprawdź i spróbuj ponownie,
+You need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,"Aby zarejestrować się w Marketplace, musisz być użytkownikiem innym niż Administrator z rolami System Manager i Item Manager.",
+You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,"Musisz być użytkownikiem z rolami System Manager i Menedżera elementów, aby dodawać użytkowników do Marketplace.",
+You need to be a user with System Manager and Item Manager roles to register on Marketplace.,"Aby zarejestrować się w Marketplace, musisz być użytkownikiem z rolami System Manager i Item Manager.",
+You need to be logged in to access this page,Musisz być zalogowany aby uzyskać dostęp do tej strony,
+You need to enable Shopping Cart,Musisz włączyć Koszyk,
+You will lose records of previously generated invoices. Are you sure you want to restart this subscription?,Utracisz zapis wcześniej wygenerowanych faktur. Czy na pewno chcesz zrestartować tę subskrypcję?,
+Your Organization,Twoja organizacja,
+Your cart is Empty,Twój koszyk jest pusty,
+Your email address...,Twój adres email...,
+Your order is out for delivery!,Twoje zamówienie jest na dostawę!,
+Your tickets,Twoje bilety,
+ZIP Code,Kod pocztowy,
+[Error],[Błąd],
+[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Postać / poz / {0}) jest niedostępne,
+`Freeze Stocks Older Than` should be smaller than %d days.,Zapasy starsze niż' powinny być starczyć na %d dni,
+based_on,oparte na,
+cannot be greater than 100,nie może być większa niż 100,
+disabled user,Wyłączony użytkownik,
+"e.g. ""Build tools for builders""","np. ""Buduj narzędzia dla budowniczych""",
+"e.g. ""Primary School"" or ""University""",np &quot;Szkoła Podstawowa&quot; lub &quot;Uniwersytet&quot;,
+"e.g. Bank, Cash, Credit Card","np. bank, gotówka, karta kredytowa",
+hidden,ukryty,
+modified,Zmodyfikowano,
+old_parent,old_parent,
+on,włączony,
+{0} '{1}' is disabled,{0} '{1}' jest wyłączony,
+{0} '{1}' not in Fiscal Year {2},{0} '{1}' nie w roku podatkowym {2},
+{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) nie może być większe niż planowana ilość ({2}) w zleceniu pracy {3},
+{0} - {1} is inactive student,{0} - {1} to nieaktywny student,
+{0} - {1} is not enrolled in the Batch {2},{0} - {1} nie jest powiązana z transakcją {2},
+{0} - {1} is not enrolled in the Course {2},{0} - {1} nie jest zapisany do kursu {2},
+{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} Budżet dla rachunku {1} w stosunku do {2} {3} wynosi {4}. Będzie przekraczać o {5},
+{0} Digest,{0} Streszczenie,
+{0} Request for {1},{0} Wniosek o {1},
+{0} Result submittted,{0} Wynik wysłano,
+{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Numery seryjne wymagane dla pozycji {1}. Podałeś {2}.,
+{0} Student Groups created.,{0} Utworzono grupy studentów.,
+{0} Students have been enrolled,{0} Studenci zostali zapisani,
+{0} against Bill {1} dated {2},{0} przed rachunkiem {1} z dnia {2},
+{0} against Purchase Order {1},{0} przed Zamówieniem Zakupu  {1},
+{0} against Sales Invoice {1},{0} na fakturę sprzedaży {1},
+{0} against Sales Order {1},{0} przed Zleceniem Sprzedaży {1},
+{0} already allocated for Employee {1} for period {2} to {3},{0} już przydzielone Pracodawcy {1} dla okresu {2} do {3},
+{0} applicable after {1} working days,{0} obowiązuje po {1} dniach roboczych,
+{0} asset cannot be transferred,{0} zasób nie może zostać przetransferowany,
+{0} can not be negative,{0} nie może być ujemna,
+{0} created,{0} utworzone,
+"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.","{0} aktualnie posiada pozycję {1} Karty wyników dostawcy, a zlecenia kupna dostawcy powinny być wydawane z ostrożnością.",
+"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.","{0} aktualnie posiada {1} tabelę wyników karty wyników, a zlecenia RFQ dla tego dostawcy powinny być wydawane z ostrożnością.",
+{0} does not belong to Company {1},{0} nie należy do firmy {1},
+{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0} nie ma harmonogramu służby zdrowia. Dodaj go do mistrza Healthcare Practitioner,
+{0} entered twice in Item Tax,{0} dwa razy wprowadzone w podatku produktu,
+{0} for {1},{0} do {1},
+{0} has been submitted successfully,{0} zostało pomyślnie przesłane,
+{0} has fee validity till {1},{0} ważność opłaty do {1},
+{0} hours,{0} godzin,
+{0} in row {1},{0} wiersze {1},
+{0} is blocked so this transaction cannot proceed,"Opcja {0} jest zablokowana, więc ta transakcja nie może być kontynuowana",
+{0} is mandatory,{0} jest obowiązkowe,
+{0} is mandatory for Item {1},{0} jest obowiązkowe dla elementu {1},
+{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,"{0} jest obowiązkowe. Możliwe, że rekord Wymiana walut nie jest utworzony dla {1} do {2}.",
+{0} is not a stock Item,{0} nie jest przechowywany na magazynie,
+{0} is not added in the table,{0} nie zostało dodane do tabeli,
+{0} is not in Optional Holiday List,{0} nie znajduje się na Opcjonalnej Liście Świątecznej,
+{0} is not in a valid Payroll Period,{0} nie jest w ważnym Okresie Rozliczeniowym,
+{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} jest teraz domyślnym rokiem finansowym. Odśwież swoją przeglądarkę aby zmiana weszła w życie,
+{0} is on hold till {1},{0} jest wstrzymane do {1},
+{0} item found.,Znaleziono {0} element.,
+{0} items found.,Znaleziono {0} przedmiotów.,
+{0} items in progress,{0} pozycji w przygotowaniu,
+{0} items produced,{0} pozycji wyprodukowanych,
+{0} must appear only once,{0} musi pojawić się tylko raz,
+{0} must be negative in return document,{0} musi być ujemna w dokumencie zwrotnym,
+{0} must be submitted,{0} musi zostać wysłany,
+{0} not allowed to transact with {1}. Please change the Company.,{0} nie może przeprowadzać transakcji z {1}. Zmień firmę.,
+{0} not found for item {1},{0} nie został znaleziony dla elementu {1},
+{0} parameter is invalid,Parametr {0} jest nieprawidłowy,
+{0} payment entries can not be filtered by {1},{0} wpisy płatności nie mogą być filtrowane przez {1},
+{0} should be a value between 0 and 100,{0} powinno być wartością z zakresu od 0 do 100,
+{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} jednostki [{1}] (# Kształt / szt / {1}) znajduje się w [{2}] (# Kształt / Warehouse / {2}),
+{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} jednostki {1} potrzebne w {2} na {3} {4} {5} w celu zrealizowania tej transakcji.,
+{0} units of {1} needed in {2} to complete this transaction.,"{0} jednostki {1} potrzebne w {2}, aby zakończyć tę transakcję.",
+{0} valid serial nos for Item {1},{0} prawidłowe numery seryjne dla Pozycji {1},
+{0} variants created.,Utworzono wariantów {0}.,
+{0} {1} created,{0} {1} utworzone,
+{0} {1} does not exist,{0} {1} nie istnieje,
+{0} {1} has been modified. Please refresh.,{0} {1} został zmodyfikowany. Proszę odświeżyć.,
+{0} {1} has not been submitted so the action cannot be completed,"{0} {1} nie został złożony, więc działanie nie może zostać zakończone",
+"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} jest powiązane z {2}, ale rachunek strony jest {3}",
+{0} {1} is cancelled or closed,{0} {1} zostanie anulowane lub zamknięte,
+{0} {1} is cancelled or stopped,{0} {1} jest anulowane lub wstrzymane,
+{0} {1} is cancelled so the action cannot be completed,"{0} {1} jest anulowany, więc działanie nie może zostać zakończone",
+{0} {1} is closed,{0} {1} jest zamknięty,
+{0} {1} is disabled,{0} {1} jest wyłączony,
+{0} {1} is frozen,{0} {1} jest zamrożone,
+{0} {1} is fully billed,{0} {1} jest w pełni rozliczone,
+{0} {1} is not active,{0} {1} jest nieaktywny,
+{0} {1} is not associated with {2} {3},{0} {1} nie jest powiązane z {2} {3},
+{0} {1} is not present in the parent company,{0} {1} nie występuje w firmie macierzystej,
+{0} {1} is not submitted,{0} {1} nie zostało dodane,
+{0} {1} is {2},{0} {1} to {2},
+{0} {1} must be submitted,{0} {1} musi zostać wysłane,
+{0} {1} not in any active Fiscal Year.,{0} {1} nie w każdej aktywnej roku obrotowego.,
+{0} {1} status is {2},{0} {1} jest ustawiony w stanie {2},
+{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,"{0} {1}: konto ""zysków i strat"" {2} jest niedozwolone w otwierającym wejściu",
+{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Rachunek {2} nie należy do firmy {3},
+{0} {1}: Account {2} is inactive,{0} {1}: Rachunek {2} jest nieaktywny,
+{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Wejście księgowe dla {2} mogą być dokonywane wyłącznie w walucie: {3},
+{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: MPK jest obowiązkowe dla pozycji {2},
+{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,"{0} {1}: Centrum kosztów jest wymagane dla rachunku ""Zyski i straty"" {2}. Proszę ustawić domyślne centrum kosztów dla firmy.",
+{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Centrum kosztów {2} nie należy do firmy {3},
+{0} {1}: Customer is required against Receivable account {2},{0} {1}: Klient zobowiązany jest przed należność {2},
+{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Debet lub wielkość kredytu jest wymagana dla {2},
+{0} {1}: Supplier is required against Payable account {2},{0} {1}: Dostawca jest wymagany w odniesieniu do konta z możliwością opłacenia {2},
+{0}% Billed,{0}% rozliczono,
+{0}% Delivered,{0}% Dostarczono,
+"{0}: Employee email not found, hence email not sent","{0}: Email pracownika nie został znaleziony, dlatego wiadomość nie będzie wysłana",
+{0}: From {0} of type {1},{0}: Od {0} typu {1},
+{0}: From {1},{0}: {1} od,
+{0}: {1} does not exists,{0}: {1} nie istnieje,
+{0}: {1} not found in Invoice Details table,{0}: {1} Nie znaleziono tabeli w Szczegóły faktury,
+{} of {},{} z {},
+Assigned To,Przypisano do,
+Chat,Czat,
+Completed By,Ukończony przez,
+Conditions,Warunki,
+County,Powiat,
+Day of Week,Dzień tygodnia,
+"Dear System Manager,",Szanowny Dyrektorze ds. Systemu,
+Default Value,Domyślna wartość,
+Email Group,Grupa email,
+Email Settings,Ustawienia wiadomości e-mail,
+Email not sent to {0} (unsubscribed / disabled),E-mail nie wysłany do {0} (wypisany / wyłączony),
+Error Message,Komunikat o błędzie,
+Fieldtype,Typ pola,
+Help Articles,Artykuły pomocy,
+ID,ID,
+Images,Obrazy,
+Import,Import,
+Language,Język,
+Likes,Lubi,
+Merge with existing,Połączy się z istniejącą,
+Office,Biuro,
+Orientation,Orientacja,
+Parent,Nadrzędny,
+Passive,Nieaktywny,
+Payment Failed,Płatność nie powiodła się,
+Percent,Procent,
+Permanent,Stały,
+Personal,Osobiste,
+Plant,Zakład,
+Post,Stanowisko,
+Postal,Pocztowy,
+Postal Code,Kod pocztowy,
+Previous,Wstecz,
+Provider,Dostawca,
+Read Only,Tylko do odczytu,
+Recipient,Adresat,
+Reviews,Recenzje,
+Sender,Nadawca,
+Shop,Sklep,
+Subsidiary,Pomocniczy,
+There is some problem with the file url: {0},Jest jakiś problem z adresem URL pliku: {0},
+There were errors while sending email. Please try again.,Wystąpiły błędy podczas wysyłki e-mail. Proszę spróbuj ponownie.,
+Values Changed,Zmienione wartości,
+or,albo,
+Ageing Range 4,Zakres starzenia się 4,
+Allocated amount cannot be greater than unadjusted amount,Kwota przydzielona nie może być większa niż kwota nieskorygowana,
+Allocated amount cannot be negative,Przydzielona kwota nie może być ujemna,
+"Difference Account must be a Asset/Liability type account, since this Stock Entry is an Opening Entry","Konto różnicowe musi być kontem typu Asset / Liability, ponieważ ten wpis na giełdę jest wpisem otwierającym",
+Error in some rows,Błąd w niektórych wierszach,
+Import Successful,Import zakończony sukcesem,
+Please save first,Zapisz najpierw,
+Price not found for item {0} in price list {1},Nie znaleziono ceny dla przedmiotu {0} w cenniku {1},
+Warehouse Type,Typ magazynu,
+'Date' is required,„Data” jest wymagana,
+Benefit,Zasiłek,
+Budgets,Budżety,
+Bundle Qty,Ilość paczek,
+Company GSTIN,Firma GSTIN,
+Company field is required,Wymagane jest pole firmowe,
+Creating Dimensions...,Tworzenie wymiarów ...,
+Duplicate entry against the item code {0} and manufacturer {1},Zduplikowany wpis względem kodu produktu {0} i producenta {1},
+Invalid GSTIN! The input you've entered doesn't match the GSTIN format for UIN Holders or Non-Resident OIDAR Service Providers,Nieprawidłowy GSTIN! Wprowadzone dane nie odpowiadają formatowi GSTIN dla posiadaczy UIN lub nierezydentów dostawców usług OIDAR,
+Invoice Grand Total,Faktura Grand Total,
+Last carbon check date cannot be a future date,Data ostatniej kontroli emisji nie może być datą przyszłą,
+Make Stock Entry,Zrób wejście na giełdę,
+Quality Feedback,Opinie dotyczące jakości,
+Quality Feedback Template,Szablon opinii o jakości,
+Rules for applying different promotional schemes.,Zasady stosowania różnych programów promocyjnych.,
+Shift,Przesunięcie,
+Show {0},Pokaż {0},
+"Special Characters except '-', '#', '.', '/', '{{' and '}}' not allowed in naming series {0}","Znaki specjalne z wyjątkiem &quot;-&quot;, &quot;#&quot;, &quot;।&quot;, &quot;/&quot;, &quot;{{&quot; I &quot;}}&quot; niedozwolone w serii nazw {0}",
+Target Details,Szczegóły celu,
+{0} already has a Parent Procedure {1}.,{0} ma już procedurę nadrzędną {1}.,
+API,API,
+Annual,Roczny,
+Approved,Zatwierdzono,
+Change,Reszta,
+Contact Email,E-mail kontaktu,
+Export Type,Typ eksportu,
+From Date,Od daty,
+Group By,Grupuj według,
+Importing {0} of {1},Importowanie {0} z {1},
+Invalid URL,nieprawidłowy URL,
+Landscape,Krajobraz,
+Last Sync On,Ostatnia synchronizacja,
+Naming Series,Seria nazw,
+No data to export,Brak danych do eksportu,
+Portrait,Portret,
+Print Heading,Nagłówek do druku,
+Scheduler Inactive,Harmonogram nieaktywny,
+Scheduler is inactive. Cannot import data.,Program planujący jest nieaktywny. Nie można zaimportować danych.,
+Show Document,Pokaż dokument,
+Show Traceback,Pokaż śledzenie,
+Video,Wideo,
+Webhook Secret,Secret Webhook,
+% Of Grand Total,% Ogólnej sumy,
+'employee_field_value' and 'timestamp' are required.,Wymagane są „wartość_pola pracownika” i „znacznik czasu”.,
+<b>Company</b> is a mandatory filter.,<b>Firma</b> jest obowiązkowym filtrem.,
+<b>From Date</b> is a mandatory filter.,<b>Od daty</b> jest obowiązkowym filtrem.,
+<b>From Time</b> cannot be later than <b>To Time</b> for {0},<b>Od godziny</b> nie może być późniejsza niż <b>do godziny</b> dla {0},
+<b>To Date</b> is a mandatory filter.,<b>To Data</b> jest obowiązkowym filtrem.,
+A new appointment has been created for you with {0},Utworzono dla ciebie nowe spotkanie z {0},
+Account Value,Wartość konta,
+Account is mandatory to get payment entries,"Konto jest obowiązkowe, aby uzyskać wpisy płatności",
+Account is not set for the dashboard chart {0},Konto nie jest ustawione dla wykresu deski rozdzielczej {0},
+Account {0} does not belong to company {1},Konto {0} nie jest przypisane do Firmy {1},
+Account {0} does not exists in the dashboard chart {1},Konto {0} nie istnieje na schemacie deski rozdzielczej {1},
+Account: <b>{0}</b> is capital Work in progress and can not be updated by Journal Entry,Konto: <b>{0}</b> to kapitał Trwają prace i nie można go zaktualizować za pomocą zapisu księgowego,
+Account: {0} is not permitted under Payment Entry,Konto: {0} jest niedozwolone w ramach wprowadzania płatności,
+Accounting Dimension <b>{0}</b> is required for 'Balance Sheet' account {1}.,Wymiar księgowy <b>{0}</b> jest wymagany dla konta „Bilans” {1}.,
+Accounting Dimension <b>{0}</b> is required for 'Profit and Loss' account {1}.,Wymiar księgowy <b>{0}</b> jest wymagany dla konta „Zysk i strata” {1}.,
+Accounting Masters,Mistrzowie rachunkowości,
+Accounting Period overlaps with {0},Okres rozliczeniowy pokrywa się z {0},
+Activity,Aktywność,
+Add / Manage Email Accounts.,Dodaj / Zarządzaj kontami poczty e-mail.,
+Add Child,Dodaj pod-element,
+Add Loan Security,Dodaj zabezpieczenia pożyczki,
+Add Multiple,Dodaj wiele,
+Add Participants,Dodaj uczestników,
+Add to Featured Item,Dodaj do polecanego elementu,
+Add your review,Dodaj swoją opinię,
+Add/Edit Coupon Conditions,Dodaj / edytuj warunki kuponu,
+Added to Featured Items,Dodano do polecanych przedmiotów,
+Added {0} ({1}),Dodano {0} ({1}),
+Address Line 1,Pierwszy wiersz adresu,
+Addresses,Adresy,
+Admission End Date should be greater than Admission Start Date.,Data zakończenia przyjęcia powinna być większa niż data rozpoczęcia przyjęcia.,
+Against Loan,Przeciw pożyczce,
+Against Loan:,Przeciw pożyczce:,
+All,Wszystko,
+All bank transactions have been created,Wszystkie transakcje bankowe zostały utworzone,
+All the depreciations has been booked,Wszystkie amortyzacje zostały zarezerwowane,
+Allocation Expired!,Przydział wygasł!,
+Allow Resetting Service Level Agreement from Support Settings.,Zezwalaj na resetowanie umowy o poziomie usług z ustawień wsparcia.,
+Amount of {0} is required for Loan closure,Kwota {0} jest wymagana do zamknięcia pożyczki,
+Amount paid cannot be zero,Kwota wypłacona nie może wynosić zero,
+Applied Coupon Code,Zastosowany kod kuponu,
+Apply Coupon Code,Wprowadź Kod Kuponu,
+Appointment Booking,Rezerwacja terminu,
+"As there are existing transactions against item {0}, you can not change the value of {1}","Ponieważ istnieje istniejące transakcje przeciwko elementu {0}, nie można zmienić wartość {1}",
+Asset Id,Identyfikator zasobu,
+Asset Value,Wartość aktywów,
+Asset Value Adjustment cannot be posted before Asset's purchase date <b>{0}</b>.,Korekta wartości aktywów nie może zostać zaksięgowana przed datą zakupu aktywów <b>{0}</b> .,
+Asset {0} does not belongs to the custodian {1},Zasób {0} nie należy do depozytariusza {1},
+Asset {0} does not belongs to the location {1},Zasób {0} nie należy do lokalizacji {1},
+At least one of the Applicable Modules should be selected,Należy wybrać co najmniej jeden z odpowiednich modułów,
+Atleast one asset has to be selected.,Należy wybrać co najmniej jeden zasób.,
+Attendance Marked,Obecność oznaczona,
+Attendance has been marked as per employee check-ins,Frekwencja została oznaczona na podstawie odprawy pracownika,
+Authentication Failed,Uwierzytelnianie nie powiodło się,
+Automatic Reconciliation,Automatyczne uzgadnianie,
+Available For Use Date,Data użycia,
+Available Stock,Dostępne zapasy,
+"Available quantity is {0}, you need {1}","Dostępna ilość to {0}, potrzebujesz {1}",
+BOM 1,LM 1,
+BOM 2,BOM 2,
+BOM Comparison Tool,Narzędzie do porównywania LM,
+BOM recursion: {0} cannot be child of {1},Rekurs BOM: {0} nie może być dzieckiem {1},
+BOM recursion: {0} cannot be parent or child of {1},Rekursja BOM: {0} nie może być rodzicem ani dzieckiem {1},
+Back to Home,Wrócić do domu,
+Back to Messages,Powrót do wiadomości,
+Bank Data mapper doesn't exist,Maper danych banku nie istnieje,
+Bank Details,Dane bankowe,
+Bank account '{0}' has been synchronized,Konto bankowe „{0}” zostało zsynchronizowane,
+Bank account {0} already exists and could not be created again,Konto bankowe {0} już istnieje i nie można go utworzyć ponownie,
+Bank accounts added,Dodano konta bankowe,
+Batch no is required for batched item {0},Nr partii jest wymagany dla pozycji wsadowej {0},
+Billing Date,Termin spłaty,
+Billing Interval Count cannot be less than 1,Liczba interwałów rozliczeniowych nie może być mniejsza niż 1,
+Blue,Niebieski,
+Book,Książka,
+Book Appointment,Umów wizytę,
+Brand,Marka,
+Browse,Przeglądaj,
+Call Connected,Połącz Połączony,
+Call Disconnected,Zadzwoń Rozłączony,
+Call Missed,Nieodebrane połączenie,
+Call Summary,Podsumowanie połączenia,
+Call Summary Saved,Podsumowanie połączeń zapisane,
+Cancelled,Anulowany,
+Cannot Calculate Arrival Time as Driver Address is Missing.,"Nie można obliczyć czasu przybycia, ponieważ brakuje adresu sterownika.",
+Cannot Optimize Route as Driver Address is Missing.,"Nie można zoptymalizować trasy, ponieważ brakuje adresu sterownika.",
+Cannot complete task {0} as its dependant task {1} are not ccompleted / cancelled.,"Nie można ukończyć zadania {0}, ponieważ jego zależne zadanie {1} nie zostało zakończone / anulowane.",
+Cannot create loan until application is approved,"Nie można utworzyć pożyczki, dopóki wniosek nie zostanie zatwierdzony",
+Cannot find a matching Item. Please select some other value for {0}.,Nie możesz znaleźć pasujący element. Proszę wybrać jakąś inną wartość dla {0}.,
+"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Nie można przepłacić za element {0} w wierszu {1} więcej niż {2}. Aby zezwolić na nadmierne fakturowanie, ustaw limit w Ustawieniach kont",
+"Capacity Planning Error, planned start time can not be same as end time","Błąd planowania wydajności, planowany czas rozpoczęcia nie może być taki sam jak czas zakończenia",
+Categories,Kategorie,
+Changes in {0},Zmiany w {0},
+Chart,Wykres,
+Choose a corresponding payment,Wybierz odpowiednią płatność,
+Click on the link below to verify your email and confirm the appointment,"Kliknij poniższy link, aby zweryfikować swój adres e-mail i potwierdzić spotkanie",
+Close,Zamknij,
+Communication,Komunikacja,
+Compact Item Print,Compact Element Drukuj,
+Company,Firma,
+Company of asset {0} and purchase document {1} doesn't matches.,Firma zasobu {0} i dokument zakupu {1} nie pasują.,
+Compare BOMs for changes in Raw Materials and Operations,Porównaj LM dla zmian w surowcach i operacjach,
+Compare List function takes on list arguments,Funkcja listy porównawczej przyjmuje argumenty listy,
+Complete,Kompletny,
+Completed,Zakończono,
+Completed Quantity,Ukończona ilość,
+Connect your Exotel Account to ERPNext and track call logs,Połącz swoje konto Exotel z ERPNext i śledź dzienniki połączeń,
+Connect your bank accounts to ERPNext,Połącz swoje konta bankowe z ERPNext,
+Contact Seller,Skontaktuj się ze sprzedawcą,
+Continue,Kontynuuj,
+Cost Center: {0} does not exist,Centrum kosztów: {0} nie istnieje,
+Couldn't Set Service Level Agreement {0}.,Nie można ustawić umowy o poziomie usług {0}.,
+Country,Kraj,
+Country Code in File does not match with country code set up in the system,Kod kraju w pliku nie zgadza się z kodem kraju skonfigurowanym w systemie,
+Create New Contact,Utwórz nowy kontakt,
+Create New Lead,Utwórz nowego potencjalnego klienta,
+Create Pick List,Utwórz listę wyboru,
+Create Quality Inspection for Item {0},Utwórz kontrolę jakości dla przedmiotu {0},
+Creating Accounts...,Tworzenie kont ...,
+Creating bank entries...,Tworzenie wpisów bankowych ...,
+Credit limit is already defined for the Company {0},Limit kredytowy jest już zdefiniowany dla firmy {0},
+Ctrl + Enter to submit,"Ctrl + Enter, aby przesłać",
+Ctrl+Enter to submit,"Ctrl + Enter, aby przesłać",
+Currency,Waluta,
+Current Status,Bieżący status,
+Customer PO,Klient PO,
+Customize,Dostosuj,
+Daily,Codziennie,
+Date,Data,
+Date Range,Zakres dat,
+Date of Birth cannot be greater than Joining Date.,Data urodzenia nie może być większa niż data przystąpienia.,
+Dear,Drogi,
+Default,Domyślny,
+Define coupon codes.,Zdefiniuj kody kuponów.,
+Delayed Days,Opóźnione dni,
+Delete,Usuń,
+Delivered Quantity,Dostarczona ilość,
+Delivery Notes,Dokumenty dostawy,
+Depreciated Amount,Amortyzowana kwota,
+Description,Opis,
+Designation,Nominacja,
+Difference Value,Różnica wartości,
+Dimension Filter,Filtr wymiarów,
+Disabled,Nieaktywny,
+Disbursement and Repayment,Wypłata i spłata,
+Distance cannot be greater than 4000 kms,Odległość nie może być większa niż 4000 km,
+Do you want to submit the material request,Czy chcesz przesłać żądanie materiałowe,
+Doctype,Doctype,
+Document {0} successfully uncleared,Dokument {0} został pomyślnie usunięty,
+Download Template,Ściągnij Szablon,
+Dr,Dr,
+Due Date,Termin,
+Duplicate,Powiel,
+Duplicate Project with Tasks,Duplikuj projekt z zadaniami,
+Duplicate project has been created,Utworzono zduplikowany projekt,
+E-Way Bill JSON can only be generated from a submitted document,e-Way Bill JSON można wygenerować tylko z przesłanego dokumentu,
+E-Way Bill JSON can only be generated from submitted document,e-Way Bill JSON można wygenerować tylko z przesłanego dokumentu,
+E-Way Bill JSON cannot be generated for Sales Return as of now,e-Way Bill JSON nie może być teraz generowany dla zwrotu sprzedaży,
+ERPNext could not find any matching payment entry,ERPNext nie mógł znaleźć żadnego pasującego wpisu płatności,
+Earliest Age,Najwcześniejszy wiek,
+Edit Details,Edytuj szczegóły,
+Edit Profile,Edytuj profil,
+Either GST Transporter ID or Vehicle No is required if Mode of Transport is Road,"Wymagany jest identyfikator transportera GST lub nr pojazdu, jeśli tryb transportu to Droga",
+Email,E-mail,
+Email Campaigns,Kampanie e-mail,
+Employee ID is linked with another instructor,Identyfikator pracownika jest powiązany z innym instruktorem,
+Employee Tax and Benefits,Podatek i świadczenia pracownicze,
+Employee is required while issuing Asset {0},Wymagany jest pracownik przy wydawaniu środka trwałego {0},
+Employee {0} does not belongs to the company {1},Pracownik {0} nie należy do firmy {1},
+Enable Auto Re-Order,Włącz automatyczne ponowne zamówienie,
+End Date of Agreement can't be less than today.,Data zakończenia umowy nie może być mniejsza niż dzisiaj.,
+End Time,Czas zakończenia,
+Energy Point Leaderboard,Tabela punktów energetycznych,
+Enter API key in Google Settings.,Wprowadź klucz API w Ustawieniach Google.,
+Enter Supplier,Wpisz dostawcę,
+Enter Value,Wpisz Wartość,
+Entity Type,Typ encji,
+Error,Błąd,
+Error in Exotel incoming call,Błąd połączenia przychodzącego Exotel,
+Error: {0} is mandatory field,Błąd: {0} to pole obowiązkowe,
+Event Link,Link do wydarzenia,
+Exception occurred while reconciling {0},Wystąpił wyjątek podczas uzgadniania {0},
+Expected and Discharge dates cannot be less than Admission Schedule date,Oczekiwana data i data zwolnienia nie mogą być krótsze niż data harmonogramu przyjęć,
+Expire Allocation,Wygaś przydział,
+Expired,Upłynął,
+Export,Eksport,
+Export not allowed. You need {0} role to export.,eksport nie jest dozwolony. Potrzebujesz {0} modeli żeby eksportować,
+Failed to add Domain,Nie udało się dodać domeny,
+Fetch Items from Warehouse,Pobierz przedmioty z magazynu,
+Fetching...,Ujmujący...,
+Field,Pole,
+File Manager,Menedżer plików,
+Filters,Filtry,
+Finding linked payments,Znajdowanie powiązanych płatności,
+Fleet Management,Fleet Management,
+Following fields are mandatory to create address:,"Aby utworzyć adres, należy podać następujące pola:",
+For Month,Na miesiąc,
+"For item {0} at row {1}, count of serial numbers does not match with the picked quantity",Dla pozycji {0} w wierszu {1} liczba numerów seryjnych nie zgadza się z pobraną ilością,
+For operation {0}: Quantity ({1}) can not be greter than pending quantity({2}),Dla operacji {0}: Ilość ({1}) nie może być greter wyższa niż ilość oczekująca ({2}),
+For quantity {0} should not be greater than work order quantity {1},Dla ilości {0} nie powinna być większa niż ilość zlecenia pracy {1},
+Free item not set in the pricing rule {0},Darmowy element nie jest ustawiony w regule cenowej {0},
+From Date and To Date are Mandatory,Od daty i daty są obowiązkowe,
+From employee is required while receiving Asset {0} to a target location,Od pracownika jest wymagany przy odbiorze Zasoby {0} do docelowej lokalizacji,
+Fuel Expense,Koszt paliwa,
+Future Payment Amount,Kwota przyszłej płatności,
+Future Payment Ref,Przyszła płatność Nr ref,
+Future Payments,Przyszłe płatności,
+GST HSN Code does not exist for one or more items,Kod GST HSN nie istnieje dla jednego lub więcej przedmiotów,
+Generate E-Way Bill JSON,Generuj e-Way Bill JSON,
+Get Items,Pobierz,
+Get Outstanding Documents,Uzyskaj znakomite dokumenty,
+Goal,Cel,
+Greater Than Amount,Większa niż kwota,
+Green,Zielony,
+Group,Grupa,
+Group By Customer,Grupuj według klienta,
+Group By Supplier,Grupuj według dostawcy,
+Group Node,Węzeł Grupy,
+Group Warehouses cannot be used in transactions. Please change the value of {0},Magazyny grupowe nie mogą być używane w transakcjach. Zmień wartość {0},
+Help,Pomoc,
+Help Article,Artykuł pomocy,
+"Helps you keep tracks of Contracts based on Supplier, Customer and Employee","Pomaga śledzić kontrakty na podstawie dostawcy, klienta i pracownika",
+Helps you manage appointments with your leads,Pomaga zarządzać spotkaniami z potencjalnymi klientami,
+Home,Start,
+IBAN is not valid,IBAN jest nieprawidłowy,
+Import Data from CSV / Excel files.,Importuj dane z plików CSV / Excel.,
+In Progress,W trakcie,
+Incoming call from {0},Połączenie przychodzące od {0},
+Incorrect Warehouse,Niepoprawny magazyn,
+Intermediate,Pośredni,
+Invalid Barcode. There is no Item attached to this barcode.,Nieprawidłowy kod kreskowy. Brak kodu dołączonego do tego kodu kreskowego.,
+Invalid credentials,Nieprawidłowe poświadczenia,
+Invite as User,Zaproś jako Użytkownik,
+Issue Priority.,Priorytet wydania.,
+Issue Type.,Typ problemu.,
+"It seems that there is an issue with the server's stripe configuration. In case of failure, the amount will get refunded to your account.","Wygląda na to, że istnieje problem z konfiguracją pasków serwera. W przypadku niepowodzenia kwota zostanie zwrócona na Twoje konto.",
+Item Reported,Zgłoszony element,
+Item listing removed,Usunięto listę produktów,
+Item quantity can not be zero,Ilość towaru nie może wynosić zero,
+Item taxes updated,Zaktualizowano podatki od towarów,
+Item {0}: {1} qty produced. ,Produkt {0}: wyprodukowano {1} sztuk.,
+Joining Date can not be greater than Leaving Date,Data dołączenia nie może być większa niż Data opuszczenia,
+Lab Test Item {0} already exist,Element testu laboratoryjnego {0} już istnieje,
+Last Issue,Ostatnie wydanie,
+Latest Age,Późne stadium,
+Leave application is linked with leave allocations {0}. Leave application cannot be set as leave without pay,Wniosek o urlop jest powiązany z przydziałem urlopu {0}. Wniosek o urlop nie może być ustawiony jako urlop bez wynagrodzenia,
+Leaves Taken,Zrobione liście,
+Less Than Amount,Mniej niż kwota,
+Liabilities,Zadłużenie,
+Loading...,Wczytuję...,
+Loan Amount exceeds maximum loan amount of {0} as per proposed securities,Kwota pożyczki przekracza maksymalną kwotę pożyczki w wysokości {0} zgodnie z proponowanymi papierami wartościowymi,
+Loan Applications from customers and employees.,Wnioski o pożyczkę od klientów i pracowników.,
+Loan Disbursement,Wypłata pożyczki,
+Loan Processes,Procesy pożyczkowe,
+Loan Security,Zabezpieczenie pożyczki,
+Loan Security Pledge,Zobowiązanie do zabezpieczenia pożyczki,
+Loan Security Pledge Created : {0},Utworzono zastaw na zabezpieczeniu pożyczki: {0},
+Loan Security Price,Cena zabezpieczenia pożyczki,
+Loan Security Price overlapping with {0},Cena zabezpieczenia kredytu pokrywająca się z {0},
+Loan Security Unpledge,Zabezpieczenie pożyczki Unpledge,
+Loan Security Value,Wartość zabezpieczenia pożyczki,
+Loan Type for interest and penalty rates,Rodzaj pożyczki na odsetki i kary pieniężne,
+Loan amount cannot be greater than {0},Kwota pożyczki nie może być większa niż {0},
+Loan is mandatory,Pożyczka jest obowiązkowa,
+Loans,Pożyczki,
+Loans provided to customers and employees.,Pożyczki udzielone klientom i pracownikom.,
+Location,Lokacja,
+Log Type is required for check-ins falling in the shift: {0}.,Typ dziennika jest wymagany w przypadku zameldowań przypadających na zmianę: {0}.,
+Looks like someone sent you to an incomplete URL. Please ask them to look into it.,"Wygląda jak ktoś wysłał do niekompletnego adresu URL. Proszę poprosić ich, aby na nią patrzeć.",
+Make Journal Entry,Dodaj wpis do dziennika,
+Make Purchase Invoice,Nowa faktura zakupu,
+Manufactured,Zrobiony fabrycznie,
+Mark Work From Home,Oznacz pracę z domu,
+Master,Magister,
+Max strength cannot be less than zero.,Maksymalna siła nie może być mniejsza niż zero.,
+Maximum attempts for this quiz reached!,Osiągnięto maksymalną liczbę prób tego quizu!,
+Message,Wiadomość,
+Missing Values Required,Uzupełnij Brakujące Wartości,
+Mobile No,Nr tel. Komórkowego,
+Mobile Number,Numer telefonu komórkowego,
+Month,Miesiąc,
+Name,Nazwa,
+Near you,Blisko Ciebie,
+Net Profit/Loss,Zysk / strata netto,
+New Expense,Nowy wydatek,
+New Invoice,Nowa faktura,
+New Payment,Nowa płatność,
+New release date should be in the future,Nowa data wydania powinna być w przyszłości,
+Newsletter,Newsletter,
+No Account matched these filters: {},Brak kont pasujących do tych filtrów: {},
+No Employee found for the given employee field value. '{}': {},Nie znaleziono pracownika dla danej wartości pola pracownika. &#39;{}&#39;: {},
+No Leaves Allocated to Employee: {0} for Leave Type: {1},Brak urlopów przydzielonych pracownikowi: {0} dla typu urlopu: {1},
+No communication found.,Nie znaleziono komunikacji.,
+No correct answer is set for {0},Brak poprawnej odpowiedzi dla {0},
+No description,Bez opisu,
+No issue has been raised by the caller.,Dzwoniący nie podniósł żadnego problemu.,
+No items to publish,Brak elementów do opublikowania,
+No outstanding invoices found,Nie znaleziono żadnych zaległych faktur,
+No outstanding invoices found for the {0} {1} which qualify the filters you have specified.,"Nie znaleziono zaległych faktur za {0} {1}, które kwalifikują określone filtry.",
+No outstanding invoices require exchange rate revaluation,Żadne zaległe faktury nie wymagają aktualizacji kursu walutowego,
+No reviews yet,Brak recenzji,
+No views yet,Brak jeszcze wyświetleń,
+Non stock items,Pozycje niedostępne,
+Not Allowed,Nie dozwolone,
+Not allowed to create accounting dimension for {0},Nie wolno tworzyć wymiaru księgowego dla {0},
+Not permitted. Please disable the Lab Test Template,Nie dozwolone. Wyłącz szablon testu laboratoryjnego,
+Note,Notatka,
+Notes: ,Notatki:,
+On Converting Opportunity,O możliwościach konwersji,
+On Purchase Order Submission,Po złożeniu zamówienia,
+On Sales Order Submission,Przy składaniu zamówienia sprzedaży,
+On Task Completion,Po zakończeniu zadania,
+On {0} Creation,W dniu {0} Creation,
+Only .csv and .xlsx files are supported currently,Aktualnie obsługiwane są tylko pliki .csv i .xlsx,
+Only expired allocation can be cancelled,Tylko wygasły przydział można anulować,
+Only users with the {0} role can create backdated leave applications,Tylko użytkownicy z rolą {0} mogą tworzyć aplikacje urlopowe z datą wsteczną,
+Open,otwarty,
+Open Contact,Otwarty kontakt,
+Open Lead,Ołów otwarty,
+Opening and Closing,Otwieranie i zamykanie,
+Operating Cost as per Work Order / BOM,Koszt operacyjny według zlecenia pracy / BOM,
+Order Amount,Kwota zamówienia,
+Page {0} of {1},Strona {0} z {1},
+Paid amount cannot be less than {0},Kwota wpłaty nie może być mniejsza niż {0},
+Parent Company must be a group company,Firma macierzysta musi być spółką grupy,
+Passing Score value should be between 0 and 100,Wartość Passing Score powinna wynosić od 0 do 100,
+Password policy cannot contain spaces or simultaneous hyphens. The format will be restructured automatically,Polityka haseł nie może zawierać spacji ani jednoczesnych myślników. Format zostanie automatycznie zrestrukturyzowany,
+Patient History,Historia pacjenta,
+Pause,Pauza,
+Pay,Zapłacone,
+Payment Document Type,Typ dokumentu płatności,
+Payment Name,Nazwa płatności,
+Penalty Amount,Kwota kary,
+Pending,W toku,
+Performance,Występ,
+Period based On,Okres oparty na,
+Perpetual inventory required for the company {0} to view this report.,"Aby przeglądać ten raport, firma musi mieć ciągłe zapasy.",
+Phone,Telefon,
+Pick List,Lista wyboru,
+Plaid authentication error,Błąd uwierzytelniania w kratkę,
+Plaid public token error,Błąd publicznego znacznika w kratkę,
+Plaid transactions sync error,Błąd synchronizacji transakcji Plaid,
+Please check the error log for details about the import errors,"Sprawdź dziennik błędów, aby uzyskać szczegółowe informacje na temat błędów importu",
+Please create <b>DATEV Settings</b> for Company <b>{}</b>.,<b>Utwórz ustawienia DATEV</b> dla firmy <b>{}</b> .,
+Please create adjustment Journal Entry for amount {0} ,Utwórz korektę Zapis księgowy dla kwoty {0},
+Please do not create more than 500 items at a time,Nie twórz więcej niż 500 pozycji naraz,
+Please enter <b>Difference Account</b> or set default <b>Stock Adjustment Account</b> for company {0},Wprowadź <b>konto różnicowe</b> lub ustaw domyślne <b>konto korekty zapasów</b> dla firmy {0},
+Please enter GSTIN and state for the Company Address {0},Wprowadź GSTIN i podaj adres firmy {0},
+Please enter Item Code to get item taxes,"Wprowadź kod produktu, aby otrzymać podatki od przedmiotu",
+Please enter Warehouse and Date,Proszę podać Magazyn i datę,
+Please enter the designation,Proszę podać oznaczenie,
+Please login as a Marketplace User to edit this item.,"Zaloguj się jako użytkownik Marketplace, aby edytować ten element.",
+Please login as a Marketplace User to report this item.,"Zaloguj się jako użytkownik Marketplace, aby zgłosić ten element.",
+Please select <b>Template Type</b> to download template,"Wybierz <b>Typ szablonu,</b> aby pobrać szablon",
+Please select Applicant Type first,Najpierw wybierz typ wnioskodawcy,
+Please select Customer first,Najpierw wybierz klienta,
+Please select Item Code first,Najpierw wybierz Kod produktu,
+Please select Loan Type for company {0},Wybierz typ pożyczki dla firmy {0},
+Please select a Delivery Note,Wybierz dowód dostawy,
+Please select a Sales Person for item: {0},Wybierz sprzedawcę dla produktu: {0},
+Please select another payment method. Stripe does not support transactions in currency '{0}',Wybierz inną metodę płatności. Stripe nie obsługuje transakcji w walucie &#39;{0}&#39;,
+Please select the customer.,Wybierz klienta.,
+Please set a Supplier against the Items to be considered in the Purchase Order.,"Proszę ustawić Dostawcę na tle Przedmiotów, które należy uwzględnić w Zamówieniu.",
+Please set account heads in GST Settings for Compnay {0},Ustaw głowice kont w Ustawieniach GST dla Compnay {0},
+Please set an email id for the Lead {0},Ustaw identyfikator e-mail dla potencjalnego klienta {0},
+Please set default UOM in Stock Settings,Proszę ustawić domyślną JM w Ustawieniach magazynowych,
+Please set filter based on Item or Warehouse due to a large amount of entries.,Ustaw filtr na podstawie pozycji lub magazynu ze względu na dużą liczbę wpisów.,
+Please set up the Campaign Schedule in the Campaign {0},Ustaw harmonogram kampanii w kampanii {0},
+Please set valid GSTIN No. in Company Address for company {0},Ustaw prawidłowy numer GSTIN w adresie firmy dla firmy {0},
+Please set {0},Ustaw {0},customer
+Please setup a default bank account for company {0},Ustaw domyślne konto bankowe dla firmy {0},
+Please specify,Sprecyzuj,
+Please specify a {0},Proszę podać {0},lead
+Pledge Status,Status zobowiązania,
+Pledge Time,Czas przyrzeczenia,
+Printing,Druk,
+Priority,Priorytet,
+Priority has been changed to {0}.,Priorytet został zmieniony na {0}.,
+Priority {0} has been repeated.,Priorytet {0} został powtórzony.,
+Processing XML Files,Przetwarzanie plików XML,
+Profitability,Rentowność,
+Project,Projekt,
+Proposed Pledges are mandatory for secured Loans,Proponowane zastawy są obowiązkowe dla zabezpieczonych pożyczek,
+Provide the academic year and set the starting and ending date.,Podaj rok akademicki i ustaw datę początkową i końcową.,
+Public token is missing for this bank,Brakuje publicznego tokena dla tego banku,
+Publish,Publikować,
+Publish 1 Item,Opublikuj 1 przedmiot,
+Publish Items,Publikuj przedmioty,
+Publish More Items,Opublikuj więcej przedmiotów,
+Publish Your First Items,Opublikuj swoje pierwsze przedmioty,
+Publish {0} Items,Opublikuj {0} przedmiotów,
+Published Items,Opublikowane przedmioty,
+Purchase Invoice cannot be made against an existing asset {0},Nie można wystawić faktury zakupu na istniejący zasób {0},
+Purchase Invoices,Faktury zakupu,
+Purchase Orders,Zlecenia kupna,
+Purchase Receipt doesn't have any Item for which Retain Sample is enabled.,"W potwierdzeniu zakupu nie ma żadnego elementu, dla którego włączona jest opcja Zachowaj próbkę.",
+Purchase Return,Zwrot zakupu,
+Qty of Finished Goods Item,Ilość produktu gotowego,
+Qty or Amount is mandatroy for loan security,Ilość lub Kwota jest mandatroy dla zabezpieczenia kredytu,
+Quality Inspection required for Item {0} to submit,Kontrola jakości wymagana do przesłania pozycji {0},
+Quantity to Manufacture,Ilość do wyprodukowania,
+Quantity to Manufacture can not be zero for the operation {0},Ilość do wyprodukowania nie może wynosić zero dla operacji {0},
+Quarterly,Kwartalnie,
+Queued,W kolejce,
+Quick Entry,Szybkie wejścia,
+Quiz {0} does not exist,Quiz {0} nie istnieje,
+Quotation Amount,Kwota oferty,
+Rate or Discount is required for the price discount.,Do obniżki ceny wymagana jest stawka lub zniżka.,
+Reason,Powód,
+Reconcile Entries,Uzgodnij wpisy,
+Reconcile this account,Uzgodnij to konto,
+Reconciled,Uzgodnione,
+Recruitment,Rekrutacja,
+Red,Czerwony,
+Refreshing,Odświeżam,
+Release date must be in the future,Data wydania musi być w przyszłości,
+Relieving Date must be greater than or equal to Date of Joining,Data zwolnienia musi być większa lub równa dacie przystąpienia,
+Rename,Zmień nazwę,
+Rename Not Allowed,Zmień nazwę na Niedozwolone,
+Repayment Method is mandatory for term loans,Metoda spłaty jest obowiązkowa w przypadku pożyczek terminowych,
+Repayment Start Date is mandatory for term loans,Data rozpoczęcia spłaty jest obowiązkowa w przypadku pożyczek terminowych,
+Report Item,Zgłoś przedmiot,
+Report this Item,Zgłoś ten przedmiot,
+Reserved Qty for Subcontract: Raw materials quantity to make subcontracted items.,Zarezerwowana ilość dla umowy podwykonawczej: ilość surowców do wytworzenia elementów podwykonawczych.,
+Reset,Nastawić,
+Reset Service Level Agreement,Zresetuj umowę o poziomie usług,
+Resetting Service Level Agreement.,Resetowanie umowy o poziomie usług.,
+Return amount cannot be greater unclaimed amount,Kwota zwrotu nie może być większa niż kwota nieodebrana,
+Review,Przejrzeć,
+Room,Pokój,
+Room Type,Rodzaj pokoju,
+Row # ,Wiersz #,
+Row #{0}: Accepted Warehouse and Supplier Warehouse cannot be same,Wiersz # {0}: Magazyn zaakceptowany i magazyn dostawcy nie mogą być takie same,
+Row #{0}: Cannot delete item {1} which has already been billed.,"Wiersz # {0}: Nie można usunąć elementu {1}, który został już rozliczony.",
+Row #{0}: Cannot delete item {1} which has already been delivered,"Wiersz # {0}: Nie można usunąć elementu {1}, który został już dostarczony",
+Row #{0}: Cannot delete item {1} which has already been received,"Wiersz # {0}: Nie można usunąć elementu {1}, który został już odebrany",
+Row #{0}: Cannot delete item {1} which has work order assigned to it.,"Wiersz # {0}: Nie można usunąć elementu {1}, któremu przypisano zlecenie pracy.",
+Row #{0}: Cannot delete item {1} which is assigned to customer's purchase order.,"Wiersz # {0}: Nie można usunąć elementu {1}, który jest przypisany do zamówienia zakupu klienta.",
+Row #{0}: Cannot select Supplier Warehouse while suppling raw materials to subcontractor,Wiersz # {0}: nie można wybrać magazynu dostawcy podczas dostarczania surowców do podwykonawcy,
+Row #{0}: Cost Center {1} does not belong to company {2},Wiersz # {0}: Centrum kosztów {1} nie należy do firmy {2},
+Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order {3}. Please update operation status via Job Card {4}.,Wiersz # {0}: operacja {1} nie została zakończona dla {2} ilości gotowych produktów w zleceniu pracy {3}. Zaktualizuj status operacji za pomocą karty pracy {4}.,
+Row #{0}: Payment document is required to complete the transaction,Wiersz # {0}: dokument płatności jest wymagany do zakończenia transakcji,
+Row #{0}: Serial No {1} does not belong to Batch {2},Wiersz # {0}: numer seryjny {1} nie należy do partii {2},
+Row #{0}: Service End Date cannot be before Invoice Posting Date,Wiersz # {0}: data zakończenia usługi nie może być wcześniejsza niż data księgowania faktury,
+Row #{0}: Service Start Date cannot be greater than Service End Date,Wiersz # {0}: data rozpoczęcia usługi nie może być większa niż data zakończenia usługi,
+Row #{0}: Service Start and End Date is required for deferred accounting,Wiersz # {0}: data rozpoczęcia i zakończenia usługi jest wymagana dla odroczonej księgowości,
+Row {0}: Invalid Item Tax Template for item {1},Wiersz {0}: nieprawidłowy szablon podatku od towarów dla towaru {1},
+Row {0}: Quantity not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Wiersz {0}: ilość niedostępna dla {4} w magazynie {1} w czasie księgowania wpisu ({2} {3}),
+Row {0}: user has not applied the rule {1} on the item {2},Wiersz {0}: użytkownik nie zastosował reguły {1} do pozycji {2},
+Row {0}:Sibling Date of Birth cannot be greater than today.,Wiersz {0}: data urodzenia rodzeństwa nie może być większa niż dzisiaj.,
+Row({0}): {1} is already discounted in {2},Wiersz ({0}): {1} jest już zdyskontowany w {2},
+Rows Added in {0},Rzędy dodane w {0},
+Rows Removed in {0},Rzędy usunięte w {0},
+Sanctioned Amount limit crossed for {0} {1},Przekroczono limit kwoty usankcjonowanej dla {0} {1},
+Sanctioned Loan Amount already exists for {0} against company {1},Kwota sankcjonowanej pożyczki już istnieje dla {0} wobec firmy {1},
+Save,Zapisz,
+Save Item,Zapisz przedmiot,
+Saved Items,Zapisane przedmioty,
+Search Items ...,Szukaj przedmiotów ...,
+Search for a payment,Wyszukaj płatność,
+Search for anything ...,Wyszukaj cokolwiek ...,
+Search results for,Wyniki wyszukiwania dla,
+Select All,Wybierz wszystko,
+Select Difference Account,Wybierz konto różnicy,
+Select a Default Priority.,Wybierz domyślny priorytet.,
+Select a company,Wybierz firmę,
+Select finance book for the item {0} at row {1},Wybierz księgę finansową dla pozycji {0} w wierszu {1},
+Select only one Priority as Default.,Wybierz tylko jeden priorytet jako domyślny.,
+Seller Information,Informacje o sprzedawcy,
+Send,Wyślij,
+Send a message,Wysłać wiadomość,
+Sending,Wysyłanie,
+Sends Mails to lead or contact based on a Campaign schedule,Wysyła wiadomości e-mail do potencjalnego klienta lub kontaktu na podstawie harmonogramu kampanii,
+Serial Number Created,Utworzono numer seryjny,
+Serial Numbers Created,Utworzono numery seryjne,
+Serial no(s) required for serialized item {0},Nie są wymagane numery seryjne dla pozycji zserializowanej {0},
+Series,Seria,
+Server Error,błąd serwera,
+Service Level Agreement has been changed to {0}.,Umowa o poziomie usług została zmieniona na {0}.,
+Service Level Agreement was reset.,Umowa o poziomie usług została zresetowana.,
+Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Umowa o poziomie usług z typem podmiotu {0} i podmiotem {1} już istnieje.,
+Set,Zbiór,
+Set Meta Tags,Ustaw meta tagi,
+Set {0} in company {1},Ustaw {0} w firmie {1},
+Setup,Ustawienia,
+Setup Wizard,Ustawienia Wizard,
+Shift Management,Zarządzanie zmianą,
+Show Future Payments,Pokaż przyszłe płatności,
+Show Linked Delivery Notes,Pokaż połączone dowody dostawy,
+Show Sales Person,Pokaż sprzedawcę,
+Show Stock Ageing Data,Pokaż dane dotyczące starzenia się zapasów,
+Show Warehouse-wise Stock,Pokaż magazyn w magazynie,
+Size,Rozmiar,
+Something went wrong while evaluating the quiz.,Coś poszło nie tak podczas oceny quizu.,
+Sr,sr,
+Start,Start,
+Start Date cannot be before the current date,Data rozpoczęcia nie może być wcześniejsza niż bieżąca data,
+Start Time,Czas rozpoczęcia,
+Status,Status,
+Status must be Cancelled or Completed,Status musi zostać anulowany lub ukończony,
+Stock Balance Report,Raport stanu zapasów,
+Stock Entry has been already created against this Pick List,Zapis zapasów został już utworzony dla tej listy pobrania,
+Stock Ledger ID,Identyfikator księgi głównej,
+Stock Value ({0}) and Account Balance ({1}) are out of sync for account {2} and it's linked warehouses.,Wartość zapasów ({0}) i saldo konta ({1}) nie są zsynchronizowane dla konta {2} i powiązanych magazynów.,
+Stores - {0},Sklepy - {0},
+Student with email {0} does not exist,Student z e-mailem {0} nie istnieje,
+Submit Review,Dodaj recenzję,
+Submitted,Zgłoszny,
+Supplier Addresses And Contacts,Adresy i kontakty dostawcy,
+Synchronize this account,Zsynchronizuj to konto,
+Tag,Etykietka,
+Target Location is required while receiving Asset {0} from an employee,Lokalizacja docelowa jest wymagana podczas otrzymywania środka {0} od pracownika,
+Target Location is required while transferring Asset {0},Lokalizacja docelowa jest wymagana podczas przenoszenia aktywów {0},
+Target Location or To Employee is required while receiving Asset {0},Lokalizacja docelowa lub Do pracownika jest wymagana podczas otrzymywania Zasobu {0},
+Task's {0} End Date cannot be after Project's End Date.,Data zakończenia zadania {0} nie może być późniejsza niż data zakończenia projektu.,
+Task's {0} Start Date cannot be after Project's End Date.,Data rozpoczęcia zadania {0} nie może być późniejsza niż data zakończenia projektu.,
+Tax Account not specified for Shopify Tax {0},Nie określono konta podatkowego dla Shopify Tax {0},
+Tax Total,Podatek ogółem,
+Template,Szablon,
+The Campaign '{0}' already exists for the {1} '{2}',Kampania „{0}” już istnieje dla {1} ”{2}”,
+The difference between from time and To Time must be a multiple of Appointment,Różnica między czasem a czasem musi być wielokrotnością terminu,
+The field Asset Account cannot be blank,Pole Konto aktywów nie może być puste,
+The field Equity/Liability Account cannot be blank,Pole Rachunek kapitału własnego / pasywnego nie może być puste,
+The following serial numbers were created: <br><br> {0},Utworzono następujące numery seryjne: <br><br> {0},
+The parent account {0} does not exists in the uploaded template,Konto nadrzędne {0} nie istnieje w przesłanym szablonie,
+The question cannot be duplicate,Pytanie nie może być duplikowane,
+The selected payment entry should be linked with a creditor bank transaction,Wybrany zapis płatności powinien być powiązany z transakcją banku wierzyciela,
+The selected payment entry should be linked with a debtor bank transaction,Wybrany zapis płatności powinien być powiązany z transakcją bankową dłużnika,
+The total allocated amount ({0}) is greated than the paid amount ({1}).,Łączna przydzielona kwota ({0}) jest przywitana niż wypłacona kwota ({1}).,
+There are no vacancies under staffing plan {0},W planie zatrudnienia nie ma wolnych miejsc pracy {0},
+This Service Level Agreement is specific to Customer {0},Niniejsza umowa dotycząca poziomu usług dotyczy wyłącznie klienta {0},
+This action will unlink this account from any external service integrating ERPNext with your bank accounts. It cannot be undone. Are you certain ?,Ta czynność spowoduje odłączenie tego konta od dowolnej usługi zewnętrznej integrującej ERPNext z kontami bankowymi. Nie można tego cofnąć. Czy jesteś pewien ?,
+This bank account is already synchronized,To konto bankowe jest już zsynchronizowane,
+This bank transaction is already fully reconciled,Ta transakcja bankowa została już w pełni uzgodniona,
+This employee already has a log with the same timestamp.{0},Ten pracownik ma już dziennik z tym samym znacznikiem czasu. {0},
+This page keeps track of items you want to buy from sellers.,"Ta strona śledzi przedmioty, które chcesz kupić od sprzedawców.",
+This page keeps track of your items in which buyers have showed some interest.,"Ta strona śledzi Twoje produkty, którymi kupujący wykazali pewne zainteresowanie.",
+Thursday,Czwartek,
+Timing,wyczucie czasu,
+Title,Tytuł,
+"To allow over billing, update ""Over Billing Allowance"" in Accounts Settings or the Item.","Aby zezwolić na rozliczenia, zaktualizuj „Over Billing Allowance” w ustawieniach kont lub pozycji.",
+"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Aby zezwolić na odbiór / dostawę, zaktualizuj „Przekazywanie / dostawę” w Ustawieniach magazynowych lub pozycji.",
+To date needs to be before from date,Do tej pory musi być wcześniejsza niż data,
+Total,Razem,
+Total Early Exits,Łącznie wczesne wyjścia,
+Total Late Entries,Późne wpisy ogółem,
+Total Payment Request amount cannot be greater than {0} amount,Łączna kwota żądania zapłaty nie może być większa niż kwota {0},
+Total payments amount can't be greater than {},Łączna kwota płatności nie może być większa niż {},
+Totals,Sumy całkowite,
+Training Event:,Wydarzenie szkoleniowe:,
+Transactions already retreived from the statement,Transakcje już wycofane z wyciągu,
+Transfer Material to Supplier,Przenieść materiał do dostawcy,
+Transport Receipt No and Date are mandatory for your chosen Mode of Transport,Nr potwierdzenia odbioru i data są obowiązkowe w wybranym trybie transportu,
+Tuesday,Wtorek,
+Type,Typ,
+Unable to find Salary Component {0},Nie można znaleźć składnika wynagrodzenia {0},
+Unable to find the time slot in the next {0} days for the operation {1}.,Nie można znaleźć przedziału czasu w ciągu najbliższych {0} dni dla operacji {1}.,
+Unable to update remote activity,Nie można zaktualizować aktywności zdalnej,
+Unknown Caller,Nieznany rozmówca,
+Unlink external integrations,Rozłącz integracje zewnętrzne,
+Unmarked Attendance for days,Nieoznakowana obecność na kilka dni,
+Unpublish Item,Cofnij publikację przedmiotu,
+Unreconciled,Nieuzgodnione,
+Unsupported GST Category for E-Way Bill JSON generation,Nieobsługiwana kategoria GST dla generacji e-Way Bill JSON,
+Update,Aktualizacja,
+Update Details,Zaktualizuj szczegóły,
+Update Taxes for Items,Zaktualizuj podatki od przedmiotów,
+"Upload a bank statement, link or reconcile a bank account","Prześlij wyciąg z konta bankowego, połącz lub rozlicz konto bankowe",
+Upload a statement,Prześlij oświadczenie,
+Use a name that is different from previous project name,Użyj nazwy innej niż nazwa poprzedniego projektu,
+User {0} is disabled,Użytkownik {0} jest wyłączony,
+Users and Permissions,Użytkownicy i uprawnienia,
+Vacancies cannot be lower than the current openings,Wolne miejsca nie mogą być niższe niż obecne otwarcia,
+Valid From Time must be lesser than Valid Upto Time.,Ważny od czasu musi być mniejszy niż Ważny do godziny.,
+Valuation Rate required for Item {0} at row {1},Kurs wyceny wymagany dla pozycji {0} w wierszu {1},
+Values Out Of Sync,Wartości niezsynchronizowane,
+Vehicle Type is required if Mode of Transport is Road,"Typ pojazdu jest wymagany, jeśli tryb transportu to Droga",
+Vendor Name,Nazwa dostawcy,
+Verify Email,zweryfikuj adres e-mail,
+View,Widok,
+View all issues from {0},Wyświetl wszystkie problemy z {0},
+View call log,Wyświetl dziennik połączeń,
+Warehouse,Magazyn,
+Warehouse not found against the account {0},Nie znaleziono magazynu dla konta {0},
+Welcome to {0},Zapraszamy do {0},
+Why do think this Item should be removed?,Dlaczego według mnie ten przedmiot powinien zostać usunięty?,
+Work Order {0}: Job Card not found for the operation {1},Zlecenie pracy {0}: Nie znaleziono karty pracy dla operacji {1},
+Workday {0} has been repeated.,Dzień roboczy {0} został powtórzony.,
+XML Files Processed,Przetwarzane pliki XML,
+Year,Rok,
+Yearly,Rocznie,
+You,Ty,
+You are not allowed to enroll for this course,Nie możesz zapisać się na ten kurs,
+You are not enrolled in program {0},Nie jesteś zarejestrowany w programie {0},
+You can Feature upto 8 items.,Możesz polecić do 8 przedmiotów.,
+You can also copy-paste this link in your browser,Można również skopiować i wkleić ten link w przeglądarce,
+You can publish upto 200 items.,Możesz opublikować do 200 pozycji.,
+You have to enable auto re-order in Stock Settings to maintain re-order levels.,"Aby utrzymać poziomy ponownego zamówienia, musisz włączyć automatyczne ponowne zamówienie w Ustawieniach zapasów.",
+You must be a registered supplier to generate e-Way Bill,"Musisz być zarejestrowanym dostawcą, aby wygenerować e-Way Bill",
+You need to login as a Marketplace User before you can add any reviews.,"Musisz się zalogować jako użytkownik portalu, aby móc dodawać recenzje.",
+Your Featured Items,Twoje polecane przedmioty,
+Your Items,Twoje przedmioty,
+Your Profile,Twój profil,
+Your rating:,Twoja ocena:,
+and,i,
+e-Way Bill already exists for this document,e-Way Bill już istnieje dla tego dokumentu,
+woocommerce - {0},woocommerce - {0},
+{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Wykorzystany kupon to {1}. Dozwolona ilość jest wyczerpana,
+{0} Name,Imię {0},
+{0} Operations: {1},{0} Operacje: {1},
+{0} bank transaction(s) created,{0} utworzono transakcje bankowe,
+{0} bank transaction(s) created and {1} errors,{0} utworzono transakcje bankowe i błędy {1},
+{0} can not be greater than {1},{0} nie może być większy niż {1},
+{0} conversations,{0} rozmów,
+{0} is not a company bank account,{0} nie jest firmowym kontem bankowym,
+{0} is not a group node. Please select a group node as parent cost center,{0} nie jest węzłem grupy. Wybierz węzeł grupy jako macierzyste centrum kosztów,
+{0} is not the default supplier for any items.,{0} nie jest domyślnym dostawcą dla żadnych przedmiotów.,
+{0} is required,{0} is wymagany,
+{0}: {1} must be less than {2},{0}: {1} musi być mniejsze niż {2},
+{} is an invalid Attendance Status.,{} to nieprawidłowy status frekwencji.,
+{} is required to generate E-Way Bill JSON,{} jest wymagane do wygenerowania E-Way Bill JSON,
+"Invalid lost reason {0}, please create a new lost reason","Nieprawidłowy utracony powód {0}, utwórz nowy utracony powód",
+Profit This Year,Zysk w tym roku,
+Total Expense,Łączny koszt,
+Total Expense This Year,Całkowity koszt w tym roku,
+Total Income,Całkowity przychód,
+Total Income This Year,Dochód ogółem w tym roku,
+Barcode,kod kreskowy,
+Bold,Pogrubienie,
+Center,Środek,
+Clear,Jasny,
+Comment,Komentarz,
+Comments,Komentarze,
+DocType,DocType,
+Download,Pobieranie,
+Left,Opuścił,
+Link,Połączyć,
+New,Nowy,
+Not Found,Nie znaleziono,
+Print,Wydrukować,
+Reference Name,Nazwa referencyjna,
+Refresh,Odśwież,
+Success,Sukces,
+Time,Czas,
+Value,Wartość,
+Actual,Rzeczywisty,
+Add to Cart,Dodaj do koszyka,
+Days Since Last Order,Dni od ostatniego zamówienia,
+In Stock,W magazynie,
+Loan Amount is mandatory,Kwota pożyczki jest obowiązkowa,
+Mode Of Payment,Rodzaj płatności,
+No students Found,Nie znaleziono studentów,
+Not in Stock,Brak na stanie,
+Please select a Customer,Proszę wybrać klienta,
+Printed On,wydrukowane na,
+Received From,Otrzymane od,
+Sales Person,Sprzedawca,
+To date cannot be before From date,"""Do daty"" nie może być terminem przed ""od daty""",
+Write Off,Odpis,
+{0} Created,{0} utworzone,
+Email Id,Identyfikator E-mail,
+No,Nie,
+Reference Doctype,DocType Odniesienia,
+User Id,Identyfikator użytkownika,
+Yes,tak,
+Actual ,Właściwy,
+Add to cart,Dodaj do koszyka,
+Budget,Budżet,
+Chart of Accounts,Plan kont,
+Customer database.,Baza danych klientów.,
+Days Since Last order,Dni od ostatniego zamówienia,
+Download as JSON,Pobierz jako JSON,
+End date can not be less than start date,"Data zakończenia nie może być wcześniejsza, niż data rozpoczęcia",
+For Default Supplier (Optional),Dla dostawcy domyślnego (opcjonalnie),
+From date cannot be greater than To date,Data od - nie może być późniejsza niż Data do,
+Group by,Grupuj według,
+In stock,W magazynie,
+Item name,Nazwa pozycji,
+Loan amount is mandatory,Kwota pożyczki jest obowiązkowa,
+Minimum Qty,Minimalna ilość,
+More details,Więcej szczegółów,
+Nature of Supplies,Natura dostaw,
+No Items found.,Nie znaleziono żadnych przedmiotów.,
+No employee found,Nie znaleziono pracowników,
+No students found,Nie znaleziono studentów,
+Not in stock,Brak na stanie,
+Not permitted,Nie dozwolone,
+Open Issues ,Otwarte kwestie,
+Open Projects ,Otwarte projekty,
+Open To Do ,Otwarty na uwagi,
+Operation Id,Operacja ID,
+Partially ordered,częściowo Zamówione,
+Please select company first,Najpierw wybierz firmę,
+Please select patient,Wybierz pacjenta,
+Printed On ,Nadrukowany na,
+Projected qty,Prognozowana ilość,
+Sales person,Sprzedawca,
+Serial No {0} Created,Stworzono nr seryjny {0},
+Source Location is required for the Asset {0},Lokalizacja źródła jest wymagana dla zasobu {0},
+Tax Id,Identyfikator podatkowy,
+To Time,Do czasu,
+To date cannot be before from date,To Date nie może być wcześniejsza niż From Date,
+Total Taxable value,Całkowita wartość podlegająca opodatkowaniu,
+Upcoming Calendar Events ,Nadchodzące wydarzenia kalendarzowe,
+Value or Qty,Wartość albo Ilość,
+Variance ,Zmienność,
+Variant of,Wariant,
+Write off,Odpis,
+hours,godziny,
+received from,otrzymane od,
+to,do,
+Cards,Karty,
+Percentage,Odsetek,
+Failed to setup defaults for country {0}. Please contact support@erpnext.com,Nie udało się skonfigurować wartości domyślnych dla kraju {0}. Skontaktuj się z support@erpnext.com,
+Row #{0}: Item {1} is not a Serialized/Batched Item. It cannot have a Serial No/Batch No against it.,Wiersz # {0}: pozycja {1} nie jest przedmiotem serializowanym / partiami. Nie może mieć numeru seryjnego / numeru partii.,
+Please set {0},Ustaw {0},
+Please set {0},Ustaw {0},supplier
+Draft,Wersja robocza,"docstatus,=,0"
+Cancelled,Anulowany,"docstatus,=,2"
+Please setup Instructor Naming System in Education > Education Settings,Skonfiguruj system nazewnictwa instruktorów w sekcji Edukacja&gt; Ustawienia edukacji,
+Please set Naming Series for {0} via Setup > Settings > Naming Series,Ustaw Serie nazw dla {0} poprzez Ustawienia&gt; Ustawienia&gt; Serie nazw,
+UOM Conversion factor ({0} -> {1}) not found for item: {2},Nie znaleziono współczynnika konwersji UOM ({0} -&gt; {1}) dla elementu: {2},
+Item Code > Item Group > Brand,Kod pozycji&gt; Grupa produktów&gt; Marka,
+Customer > Customer Group > Territory,Klient&gt; Grupa klientów&gt; Terytorium,
+Supplier > Supplier Type,Dostawca&gt; Rodzaj dostawcy,
+Please setup Employee Naming System in Human Resource > HR Settings,Skonfiguruj system nazewnictwa pracowników w dziale Zasoby ludzkie&gt; Ustawienia HR,
+Please setup numbering series for Attendance via Setup > Numbering Series,Skonfiguruj serie numeracji dla frekwencji poprzez Ustawienia&gt; Serie numeracji,
+The value of {0} differs between Items {1} and {2},Wartość {0} różni się między elementami {1} i {2},
+Auto Fetch,Automatyczne pobieranie,
+Fetch Serial Numbers based on FIFO,Pobierz numery seryjne na podstawie FIFO,
+"Outward taxable supplies(other than zero rated, nil rated and exempted)","Dostawy podlegające opodatkowaniu zewnętrznemu (inne niż zerowe, zerowe i zwolnione)",
+"To allow different rates, disable the {0} checkbox in {1}.","Aby zezwolić na różne stawki, wyłącz {0} pole wyboru w {1}.",
+Current Odometer Value should be greater than Last Odometer Value {0},Bieżąca wartość drogomierza powinna być większa niż ostatnia wartość drogomierza {0},
+No additional expenses has been added,Nie dodano żadnych dodatkowych kosztów,
+Asset{} {assets_link} created for {},Zasób {} {asset_link} utworzony dla {},
+Row {}: Asset Naming Series is mandatory for the auto creation for item {},Wiersz {}: Seria nazewnictwa zasobów jest wymagana w przypadku automatycznego tworzenia elementu {},
+Assets not created for {0}. You will have to create asset manually.,Zasoby nie zostały utworzone dla {0}. Będziesz musiał utworzyć zasób ręcznie.,
+{0} {1} has accounting entries in currency {2} for company {3}. Please select a receivable or payable account with currency {2}.,{0} {1} ma zapisy księgowe w walucie {2} firmy {3}. Wybierz konto należności lub zobowiązania w walucie {2}.,
+Invalid Account,Nieważne konto,
+Purchase Order Required,Wymagane zamówienia kupna,
+Purchase Receipt Required,Wymagane potwierdzenie zakupu,
+Account Missing,Brak konta,
+Requested,Zamówiony,
+Partially Paid,Częściowo wypłacone,
+Invalid Account Currency,Nieprawidłowa waluta konta,
+"Row {0}: The item {1}, quantity must be positive number","Wiersz {0}: pozycja {1}, ilość musi być liczbą dodatnią",
+"Please set {0} for Batched Item {1}, which is used to set {2} on Submit.","Ustaw {0} dla pozycji wsadowej {1}, która jest używana do ustawiania {2} podczas przesyłania.",
+Expiry Date Mandatory,Data wygaśnięcia jest obowiązkowa,
+Variant Item,Wariant pozycji,
+BOM 1 {0} and BOM 2 {1} should not be same,BOM 1 {0} i BOM 2 {1} nie powinny być takie same,
+Note: Item {0} added multiple times,Uwaga: element {0} został dodany wiele razy,
+YouTube,Youtube,
+Vimeo,Vimeo,
+Publish Date,Data publikacji,
+Duration,Trwanie,
+Advanced Settings,Zaawansowane ustawienia,
+Path,Ścieżka,
+Components,składniki,
+Verified By,Zweryfikowane przez,
+Invalid naming series (. missing) for {0},Nieprawidłowa seria nazw (brak.) Dla {0},
+Filter Based On,Filtruj na podstawie,
+Reqd by date,Wymagane według daty,
+Manufacturer Part Number <b>{0}</b> is invalid,Numer części producenta <b>{0}</b> jest nieprawidłowy,
+Invalid Part Number,Nieprawidłowy numer części,
+Select atleast one Social Media from Share on.,Wybierz co najmniej jeden serwis społecznościowy z Udostępnij na.,
+Invalid Scheduled Time,Nieprawidłowy zaplanowany czas,
+Length Must be less than 280.,Długość musi być mniejsza niż 280.,
+Error while POSTING {0},Błąd podczas WPISYWANIA {0},
+"Session not valid, Do you want to login?","Sesja nieważna, czy chcesz się zalogować?",
+Session Active,Sesja aktywna,
+Session Not Active. Save doc to login.,"Sesja nieaktywna. Zapisz dokument, aby się zalogować.",
+Error! Failed to get request token.,Błąd! Nie udało się uzyskać tokena żądania.,
+Invalid {0} or {1},Nieprawidłowy {0} lub {1},
+Error! Failed to get access token.,Błąd! Nie udało się uzyskać tokena dostępu.,
+Invalid Consumer Key or Consumer Secret Key,Nieprawidłowy klucz klienta lub tajny klucz klienta,
+Your Session will be expire in ,Twoja sesja wygaśnie za,
+ days.,dni.,
+Session is expired. Save doc to login.,"Sesja wygasła. Zapisz dokument, aby się zalogować.",
+Error While Uploading Image,Błąd podczas przesyłania obrazu,
+You Didn't have permission to access this API,Nie masz uprawnień dostępu do tego interfejsu API,
+Valid Upto date cannot be before Valid From date,Data Valid Upto nie może być wcześniejsza niż data Valid From,
+Valid From date not in Fiscal Year {0},Data ważności od nie w roku podatkowym {0},
+Valid Upto date not in Fiscal Year {0},Ważna data ważności nie w roku podatkowym {0},
+Group Roll No,Group Roll No,
+Maintain Same Rate Throughout Sales Cycle,Utrzymanie tej samej stawki przez cały cykl sprzedaży,
+"Row {1}: Quantity ({0}) cannot be a fraction. To allow this, disable '{2}' in UOM {3}.","Wiersz {1}: ilość ({0}) nie może być ułamkiem. Aby to umożliwić, wyłącz &#39;{2}&#39; w UOM {3}.",
+Must be Whole Number,Musi być liczbą całkowitą,
+Please setup Razorpay Plan ID,Skonfiguruj identyfikator planu Razorpay,
+Contact Creation Failed,Utworzenie kontaktu nie powiodło się,
+{0} already exists for employee {1} and period {2},{0} już istnieje dla pracownika {1} i okresu {2},
+Leaves Allocated,Liście przydzielone,
+Leaves Expired,Liście wygasły,
+Leave Without Pay does not match with approved {} records,Urlop bez wynagrodzenia nie zgadza się z zatwierdzonymi rekordami {},
+Income Tax Slab not set in Salary Structure Assignment: {0},Podatek dochodowy nie jest ustawiony w przypisaniu struktury wynagrodzenia: {0},
+Income Tax Slab: {0} is disabled,Płyta podatku dochodowego: {0} jest wyłączona,
+Income Tax Slab must be effective on or before Payroll Period Start Date: {0},Płyta podatku dochodowego musi obowiązywać w dniu rozpoczęcia okresu wypłaty wynagrodzenia lub wcześniej: {0},
+No leave record found for employee {0} on {1},Nie znaleziono rekordu urlopu dla pracownika {0} w dniu {1},
+Row {0}: {1} is required in the expenses table to book an expense claim.,"Wiersz {0}: {1} jest wymagany w tabeli wydatków, aby zarezerwować wniosek o zwrot wydatków.",
+Set the default account for the {0} {1},Ustaw domyślne konto dla {0} {1},
+(Half Day),(Połowa dnia),
+Income Tax Slab,Płyta podatku dochodowego,
+Row #{0}: Cannot set amount or formula for Salary Component {1} with Variable Based On Taxable Salary,Wiersz nr {0}: nie można ustawić kwoty lub formuły dla składnika wynagrodzenia {1} ze zmienną opartą na wynagrodzeniu podlegającym opodatkowaniu,
+Row #{}: {} of {} should be {}. Please modify the account or select a different account.,Wiersz nr {}: {} z {} powinien być {}. Zmodyfikuj konto lub wybierz inne konto.,
+Row #{}: Please asign task to a member.,Wiersz nr {}: Przydziel zadanie członkowi.,
+Process Failed,Proces nie powiódł się,
+Tally Migration Error,Błąd migracji Tally,
+Please set Warehouse in Woocommerce Settings,Ustaw Magazyn w Ustawieniach Woocommerce,
+Row {0}: Delivery Warehouse ({1}) and Customer Warehouse ({2}) can not be same,Wiersz {0}: Magazyn dostaw ({1}) i Magazyn klienta ({2}) nie mogą być takie same,
+Row {0}: Due Date in the Payment Terms table cannot be before Posting Date,Wiersz {0}: Termin płatności w tabeli Warunki płatności nie może być wcześniejszy niż data księgowania,
+Cannot find {} for item {}. Please set the same in Item Master or Stock Settings.,Nie można znaleźć {} dla elementu {}. Proszę ustawić to samo w pozycji Główny lub Ustawienia zapasów.,
+Row #{0}: The batch {1} has already expired.,Wiersz nr {0}: partia {1} już wygasła.,
+Start Year and End Year are mandatory,Rok rozpoczęcia i rok zakończenia są obowiązkowe,
+GL Entry,Wejście GL,
+Cannot allocate more than {0} against payment term {1},Nie można przydzielić więcej niż {0} na okres płatności {1},
+The root account {0} must be a group,Konto root {0} musi być grupą,
+Shipping rule not applicable for country {0} in Shipping Address,Reguła dostawy nie dotyczy kraju {0} w adresie dostawy,
+Get Payments from,Otrzymuj płatności od,
+Set Shipping Address or Billing Address,Ustaw adres wysyłki lub adres rozliczeniowy,
+Consultation Setup,Konfiguracja konsultacji,
+Fee Validity,Ważność opłaty,
+Laboratory Setup,Przygotowanie laboratorium,
+Dosage Form,Forma dawkowania,
+Records and History,Zapisy i historia,
+Patient Medical Record,Medyczny dokument medyczny pacjenta,
+Rehabilitation,Rehabilitacja,
+Exercise Type,Typ ćwiczenia,
+Exercise Difficulty Level,Poziom trudności ćwiczeń,
+Therapy Type,Rodzaj terapii,
+Therapy Plan,Plan terapii,
+Therapy Session,Sesja terapeutyczna,
+Motor Assessment Scale,Skala Oceny Motorycznej,
+[Important] [ERPNext] Auto Reorder Errors,[Ważne] [ERPNext] Błędy automatycznego ponownego zamawiania,
+"Regards,","Pozdrowienia,",
+The following {0} were created: {1},Utworzono następujące {0}: {1},
+Work Orders,Zlecenia pracy,
+The {0} {1} created sucessfully,{0} {1} został pomyślnie utworzony,
+Work Order cannot be created for following reason: <br> {0},Nie można utworzyć zlecenia pracy z następującego powodu:<br> {0},
+Add items in the Item Locations table,Dodaj pozycje w tabeli Lokalizacje pozycji,
+Update Current Stock,Zaktualizuj aktualne zapasy,
+"{0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Zachowaj próbkę na podstawie partii. Zaznacz opcję Ma nr partii, aby zachować próbkę elementu",
+Empty,Pusty,
+Currently no stock available in any warehouse,Obecnie nie ma zapasów w żadnym magazynie,
+BOM Qty,BOM Qty,
+Time logs are required for {0} {1},Dzienniki czasu są wymagane dla {0} {1},
+Total Completed Qty,Całkowita ukończona ilość,
+Qty to Manufacture,Ilość do wyprodukowania,
+Repay From Salary can be selected only for term loans,Spłata z wynagrodzenia może być wybrana tylko dla pożyczek terminowych,
+No valid Loan Security Price found for {0},Nie znaleziono prawidłowej ceny zabezpieczenia pożyczki dla {0},
+Loan Account and Payment Account cannot be same,Rachunek pożyczki i rachunek płatniczy nie mogą być takie same,
+Loan Security Pledge can only be created for secured loans,Zabezpieczenie pożyczki można ustanowić tylko w przypadku pożyczek zabezpieczonych,
+Social Media Campaigns,Kampanie w mediach społecznościowych,
+From Date can not be greater than To Date,Data początkowa nie może być większa niż data początkowa,
+Please set a Customer linked to the Patient,Ustaw klienta powiązanego z pacjentem,
+Customer Not Found,Nie znaleziono klienta,
+Please Configure Clinical Procedure Consumable Item in ,Skonfiguruj materiał eksploatacyjny do procedury klinicznej w,
+Missing Configuration,Brak konfiguracji,
+Out Patient Consulting Charge Item,Out Patient Consulting Charge Item,
+Inpatient Visit Charge Item,Opłata za wizyta stacjonarna,
+OP Consulting Charge,OP Consulting Charge,
+Inpatient Visit Charge,Opłata za wizytę stacjonarną,
+Appointment Status,Status spotkania,
+Test: ,Test:,
+Collection Details: ,Szczegóły kolekcji:,
+{0} out of {1},{0} z {1},
+Select Therapy Type,Wybierz typ terapii,
+{0} sessions completed,Ukończono {0} sesje,
+{0} session completed,Sesja {0} zakończona,
+ out of {0},z {0},
+Therapy Sessions,Sesje terapeutyczne,
+Add Exercise Step,Dodaj krok ćwiczenia,
+Edit Exercise Step,Edytuj krok ćwiczenia,
+Patient Appointments,Spotkania pacjentów,
+Item with Item Code {0} already exists,Przedmiot o kodzie pozycji {0} już istnieje,
+Registration Fee cannot be negative or zero,Opłata rejestracyjna nie może być ujemna ani zerowa,
+Configure a service Item for {0},Skonfiguruj usługę dla {0},
+Temperature: ,Temperatura:,
+Pulse: ,Puls:,
+Respiratory Rate: ,Częstość oddechów:,
+BP: ,BP:,
+BMI: ,BMI:,
+Note: ,Uwaga:,
+Check Availability,Sprawdź dostępność,
+Please select Patient first,Najpierw wybierz pacjenta,
+Please select a Mode of Payment first,Najpierw wybierz sposób płatności,
+Please set the Paid Amount first,Najpierw ustaw Kwotę do zapłaty,
+Not Therapies Prescribed,Nie przepisane terapie,
+There are no Therapies prescribed for Patient {0},Nie ma przepisanych terapii dla pacjenta {0},
+Appointment date and Healthcare Practitioner are Mandatory,Data wizyty i lekarz są obowiązkowe,
+No Prescribed Procedures found for the selected Patient,Nie znaleziono przepisanych procedur dla wybranego pacjenta,
+Please select a Patient first,Najpierw wybierz pacjenta,
+There are no procedure prescribed for ,Nie ma określonej procedury,
+Prescribed Therapies,Terapie przepisane,
+Appointment overlaps with ,Termin pokrywa się z,
+{0} has appointment scheduled with {1} at {2} having {3} minute(s) duration.,{0} ma zaplanowane spotkanie z {1} na {2} trwające {3} minut (y).,
+Appointments Overlapping,Nakładające się terminy,
+Consulting Charges: {0},Opłaty za konsultacje: {0},
+Appointment Cancelled. Please review and cancel the invoice {0},Spotkanie odwołane. Sprawdź i anuluj fakturę {0},
+Appointment Cancelled.,Spotkanie odwołane.,
+Fee Validity {0} updated.,Zaktualizowano ważność opłaty {0}.,
+Practitioner Schedule Not Found,Nie znaleziono harmonogramu lekarza,
+{0} is on a Half day Leave on {1},{0} korzysta z urlopu półdniowego dnia {1},
+{0} is on Leave on {1},{0} jest na urlopie na {1},
+{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner,{0} nie ma harmonogramu lekarzy. Dodaj go do lekarza,
+Healthcare Service Units,Jednostki opieki zdrowotnej,
+Complete and Consume,Uzupełnij i zużyj,
+Complete {0} and Consume Stock?,Uzupełnić {0} i zużyć zapasy?,
+Complete {0}?,Ukończono {0}?,
+Stock quantity to start the Procedure is not available in the Warehouse {0}. Do you want to record a Stock Entry?,Ilość zapasów potrzebna do rozpoczęcia procedury nie jest dostępna w magazynie {0}. Czy chcesz zarejestrować wejście na giełdę?,
+{0} as on {1},{0} jak w dniu {1},
+Clinical Procedure ({0}):,Procedura kliniczna ({0}):,
+Please set Customer in Patient {0},Ustaw klienta jako pacjenta {0},
+Item {0} is not active,Przedmiot {0} nie jest aktywny,
+Therapy Plan {0} created successfully.,Plan terapii {0} został utworzony pomyślnie.,
+Symptoms: ,Objawy:,
+No Symptoms,Brak objawów,
+Diagnosis: ,Diagnoza:,
+No Diagnosis,Brak diagnozy,
+Drug(s) Prescribed.,Leki przepisane.,
+Test(s) Prescribed.,Test (y) przepisane.,
+Procedure(s) Prescribed.,Procedura (-y) zalecana (-e).,
+Counts Completed: {0},Liczenie zakończone: {0},
+Patient Assessment,Ocena stanu pacjenta,
+Assessments,Oceny,
+Heads (or groups) against which Accounting Entries are made and balances are maintained.,"Heads (lub grupy), przeciwko którym zapisy księgowe są i sald są utrzymywane.",
+Account Name,Nazwa konta,
+Inter Company Account,Konto firmowe Inter,
+Parent Account,Nadrzędne konto,
+Setting Account Type helps in selecting this Account in transactions.,Ustawienie Typu Konta pomaga w wyborze tego konta w transakcji.,
+Chargeable,Odpowedni do pobierania opłaty.,
+Rate at which this tax is applied,Stawka przy użyciu której ten podatek jest aplikowany,
+Frozen,Zamrożony,
+"If the account is frozen, entries are allowed to restricted users.","Jeśli konto jest zamrożone, zapisy mogą wykonywać tylko wyznaczone osoby.",
+Balance must be,Bilans powinien wynosić,
+Lft,Lft,
+Rgt,Rgt,
+Old Parent,Stary obiekt nadrzędny,
+Include in gross,Uwzględnij w brutto,
+Auditor,Audytor,
+Accounting Dimension,Wymiar księgowy,
+Dimension Name,Nazwa wymiaru,
+Dimension Defaults,Domyślne wymiary,
+Accounting Dimension Detail,Szczegóły wymiaru księgowości,
+Default Dimension,Domyślny wymiar,
+Mandatory For Balance Sheet,Obowiązkowe dla bilansu,
+Mandatory For Profit and Loss Account,Obowiązkowe dla rachunku zysków i strat,
+Accounting Period,Okres Księgowy,
+Period Name,Nazwa okresu,
+Closed Documents,Zamknięte dokumenty,
+Accounts Settings,Ustawienia Kont,
+Settings for Accounts,Ustawienia Konta,
+Make Accounting Entry For Every Stock Movement,Tworzenie Zapisów Księgowych dla każdej zmiany stanu Magazynu,
+Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Użytkownicy z tą rolą mogą ustawiać zamrożone konta i tworzyć / modyfikować wpisy księgowe dla zamrożonych kont,
+Determine Address Tax Category From,Określ kategorię podatku adresowego od,
+Over Billing Allowance (%),Over Billing Allowance (%),
+Check Supplier Invoice Number Uniqueness,"Sprawdź, czy numer faktury dostawcy jest unikalny",
+Make Payment via Journal Entry,Wykonywanie płatności za pośrednictwem Zapisów Księgowych dziennika,
+Unlink Payment on Cancellation of Invoice,Odłączanie Przedpłata na Anulowanie faktury,
+Book Asset Depreciation Entry Automatically,Automatycznie wprowadź wartość księgowania depozytu księgowego aktywów,
+Automatically Add Taxes and Charges from Item Tax Template,Automatycznie dodawaj podatki i opłaty z szablonu podatku od towarów,
+Automatically Fetch Payment Terms,Automatycznie pobierz warunki płatności,
+Show Payment Schedule in Print,Pokaż harmonogram płatności w druku,
+Currency Exchange Settings,Ustawienia wymiany walut,
+Allow Stale Exchange Rates,Zezwalaj na Stałe Kursy walut,
+Stale Days,Stale Dni,
+Report Settings,Ustawienia raportu,
+Use Custom Cash Flow Format,Użyj niestandardowego formatu przepływu środków pieniężnych,
+Allowed To Transact With,Zezwolono na zawieranie transakcji przy użyciu,
+SWIFT number,Numer swift,
+Branch Code,Kod oddziału,
+Address and Contact,Adres i Kontakt,
+Address HTML,Adres HTML,
+Contact HTML,HTML kontaktu,
+Data Import Configuration,Konfiguracja importu danych,
+Bank Transaction Mapping,Mapowanie transakcji bankowych,
+Plaid Access Token,Token dostępu do kratki,
+Company Account,Konto firmowe,
+Account Subtype,Podtyp konta,
+Is Default Account,Jest kontem domyślnym,
+Is Company Account,Jest kontem firmowym,
+Party Details,Strona Szczegóły,
+Account Details,Szczegóły konta,
+IBAN,IBAN,
+Bank Account No,Nr konta bankowego,
+Integration Details,Szczegóły integracji,
+Integration ID,Identyfikator integracji,
+Last Integration Date,Ostatnia data integracji,
+Change this date manually to setup the next synchronization start date,"Zmień tę datę ręcznie, aby ustawić następną datę rozpoczęcia synchronizacji",
+Mask,Maska,
+Bank Account Subtype,Podtyp konta bankowego,
+Bank Account Type,Typ konta bankowego,
+Bank Guarantee,Gwarancja bankowa,
+Bank Guarantee Type,Rodzaj gwarancji bankowej,
+Receiving,Odbieranie,
+Providing,Że,
+Reference Document Name,Nazwa dokumentu referencyjnego,
+Validity in Days,Ważność w dniach,
+Bank Account Info,Informacje o koncie bankowym,
+Clauses and Conditions,Klauzule i warunki,
+Other Details,Inne szczegóły,
+Bank Guarantee Number,Numer Gwarancji Bankowej,
+Name of Beneficiary,Imię beneficjenta,
+Margin Money,Marża pieniężna,
+Charges Incurred,Naliczone opłaty,
+Fixed Deposit Number,Naprawiono numer depozytu,
+Account Currency,Waluta konta,
+Select the Bank Account to reconcile.,Wybierz konto bankowe do uzgodnienia.,
+Include Reconciled Entries,Dołącz uzgodnione wpisy,
+Get Payment Entries,Uzyskaj Wpisy płatności,
+Payment Entries,Wpisy płatności,
+Update Clearance Date,Aktualizacja daty rozliczenia,
+Bank Reconciliation Detail,Uzgodnienia z wyciągiem bankowym - szczegóły,
+Cheque Number,Numer czeku,
+Cheque Date,Data czeku,
+Statement Header Mapping,Mapowanie nagłówków instrukcji,
+Statement Headers,Nagłówki instrukcji,
+Transaction Data Mapping,Mapowanie danych transakcji,
+Mapped Items,Zmapowane elementy,
+Bank Statement Settings Item,Ustawienia wyciągu bankowego Pozycja,
+Mapped Header,Mapowany nagłówek,
+Bank Header,Nagłówek banku,
+Bank Statement Transaction Entry,Wpis transakcji z wyciągu bankowego,
+Bank Transaction Entries,Wpisy transakcji bankowych,
+New Transactions,Nowe transakcje,
+Match Transaction to Invoices,Dopasuj transakcję do faktur,
+Create New Payment/Journal Entry,Utwórz nową pozycję płatności / księgowania,
+Submit/Reconcile Payments,Wpisz/Uzgodnij płatności,
+Matching Invoices,Dopasowanie faktur,
+Payment Invoice Items,Faktury z płatności,
+Reconciled Transactions,Uzgodnione transakcje,
+Bank Statement Transaction Invoice Item,Wyciąg z rachunku bankowego,
+Payment Description,Opis płatności,
+Invoice Date,Data faktury,
+invoice,faktura,
+Bank Statement Transaction Payment Item,Wyciąg z transakcji bankowych,
+outstanding_amount,pozostająca kwota,
+Payment Reference,Referencje płatności,
+Bank Statement Transaction Settings Item,Ustawienia transakcji bankowych Pozycja,
+Bank Data,Dane bankowe,
+Mapped Data Type,Zmapowany typ danych,
+Mapped Data,Zmapowane dane,
+Bank Transaction,Transakcja bankowa,
+ACC-BTN-.YYYY.-,ACC-BTN-.YYYY.-,
+Transaction ID,Identyfikator transakcji,
+Unallocated Amount,Kwota nieprzydzielone,
+Field in Bank Transaction,Pole w transakcji bankowej,
+Column in Bank File,Kolumna w pliku banku,
+Bank Transaction Payments,Płatności transakcji bankowych,
+Control Action,Działanie kontrolne,
+Applicable on Material Request,Obowiązuje na wniosek materiałowy,
+Action if Annual Budget Exceeded on MR,"Działanie, jeśli budżet roczny przekroczy MR",
+Warn,Ostrzeż,
+Ignore,Ignoruj,
+Action if Accumulated Monthly Budget Exceeded on MR,"Działanie, jeżeli skumulowany budżet miesięczny przekroczył MR",
+Applicable on Purchase Order,Obowiązuje w przypadku zamówienia zakupu,
+Action if Annual Budget Exceeded on PO,"Działanie, jeśli budżet roczny został przekroczony dla zamówienia",
+Action if Accumulated Monthly Budget Exceeded on PO,"Działanie, jeśli skumulowany miesięczny budżet został przekroczony dla zamówienia",
+Applicable on booking actual expenses,Obowiązuje przy rezerwacji rzeczywistych wydatków,
+Action if Annual Budget Exceeded on Actual,"Działanie, jeśli budżet roczny przekroczyłby rzeczywisty",
+Action if Accumulated Monthly Budget Exceeded on Actual,"Działanie, jeżeli skumulowany budżet miesięczny przekroczył rzeczywisty",
+Budget Accounts,Rachunki ekonomiczne,
+Budget Account,Budżet Konta,
+Budget Amount,budżet Kwota,
+ACC-CF-.YYYY.-,ACC-CF-.RRRR.-,
+Received Date,Data Otrzymania,
+Quarter,Kwartał,
+I,ja,
+II,II,
+III,III,
+IV,IV,
+Invoice No,Nr faktury,
+Cash Flow Mapper,Mapper przepływu gotówki,
+Section Name,Nazwa sekcji,
+Section Header,Nagłówek sekcji,
+Section Leader,Kierownik sekcji,
+e.g Adjustments for:,np. korekty dla:,
+Section Subtotal,Podsuma sekcji,
+Section Footer,Sekcja stopki,
+Position,Pozycja,
+Cash Flow Mapping,Mapowanie przepływów pieniężnych,
+Select Maximum Of 1,Wybierz Maksimum 1,
+Is Finance Cost,Koszt finansowy,
+Is Working Capital,Jest kapitałem obrotowym,
+Is Finance Cost Adjustment,Czy korekta kosztów finansowych,
+Is Income Tax Liability,Jest odpowiedzialnością z tytułu podatku dochodowego,
+Is Income Tax Expense,Jest kosztem podatku dochodowego,
+Cash Flow Mapping Accounts,Konta mapowania przepływów pieniężnych,
+account,Konto,
+Cash Flow Mapping Template,Szablon mapowania przepływów pieniężnych,
+Cash Flow Mapping Template Details,Szczegóły szablonu mapowania przepływu gotówki,
+POS-CLO-,POS-CLO-,
+Custody,Opieka,
+Net Amount,Kwota netto,
+Cashier Closing Payments,Kasjer Zamykanie płatności,
+Chart of Accounts Importer,Importer planu kont,
+Import Chart of Accounts from a csv file,Importuj plan kont z pliku csv,
+Attach custom Chart of Accounts file,Dołącz niestandardowy plik planu kont,
+Chart Preview,Podgląd wykresu,
+Chart Tree,Drzewo wykresów,
+Cheque Print Template,Sprawdź Szablon druku,
+Has Print Format,Ma format wydruku,
+Primary Settings,Ustawienia podstawowe,
+Cheque Size,Czek Rozmiar,
+Regular,Regularny,
+Starting position from top edge,stanowisko od górnej krawędzi Zaczynając,
+Cheque Width,Czek Szerokość,
+Cheque Height,Czek Wysokość,
+Scanned Cheque,zeskanowanych Czek,
+Is Account Payable,Czy Account Payable,
+Distance from top edge,Odległość od górnej krawędzi,
+Distance from left edge,Odległość od lewej krawędzi,
+Message to show,Wiadomość pokazać,
+Date Settings,Data Ustawienia,
+Starting location from left edge,Zaczynając od lewej krawędzi lokalizację,
+Payer Settings,Ustawienia płatnik,
+Width of amount in word,Szerokość kwoty w słowie,
+Line spacing for amount in words,Odstępy między wierszami dla kwoty w słowach,
+Amount In Figure,Kwota Na rysunku,
+Signatory Position,Sygnatariusz Pozycja,
+Closed Document,Zamknięty dokument,
+Track separate Income and Expense for product verticals or divisions.,Śledź oddzielnie przychody i koszty dla branż produktowych lub oddziałów.,
+Cost Center Name,Nazwa Centrum Kosztów,
+Parent Cost Center,Nadrzędny dział kalkulacji kosztów,
+lft,lft,
+rgt,rgt,
+Coupon Code,Kod kuponu,
+Coupon Name,Nazwa kuponu,
+"e.g. ""Summer Holiday 2019 Offer 20""",np. „Oferta na wakacje 2019 r. 20”,
+Coupon Type,Rodzaj kuponu,
+Promotional,Promocyjny,
+Gift Card,Karta podarunkowa,
+unique e.g. SAVE20  To be used to get discount,unikatowy np. SAVE20 Do wykorzystania w celu uzyskania rabatu,
+Validity and Usage,Ważność i użycie,
+Valid From,Ważne od,
+Valid Upto,Valid Upto,
+Maximum Use,Maksymalne wykorzystanie,
+Used,Używany,
+Coupon Description,Opis kuponu,
+Discounted Invoice,Zniżka na fakturze,
+Debit to,Obciąż do,
+Exchange Rate Revaluation,Przeszacowanie kursu wymiany,
+Get Entries,Uzyskaj wpisy,
+Exchange Rate Revaluation Account,Rachunek przeszacowania kursu wymiany,
+Total Gain/Loss,Całkowity wzrost / strata,
+Balance In Account Currency,Waluta konta w walucie,
+Current Exchange Rate,Aktualny kurs wymiany,
+Balance In Base Currency,Saldo w walucie podstawowej,
+New Exchange Rate,Nowy kurs wymiany,
+New Balance In Base Currency,Nowe saldo w walucie podstawowej,
+Gain/Loss,Zysk / strata,
+**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Rok finansowy** reprezentuje rok finansowy. Wszystkie zapisy księgowe oraz inne znaczące transakcje są śledzone przed ** roku podatkowego **.,
+Year Name,Nazwa roku,
+"For e.g. 2012, 2012-13","np. 2012, 2012-13",
+Year Start Date,Data początku roku,
+Year End Date,Data końca roku,
+Companies,Firmy,
+Auto Created,Automatycznie utworzone,
+Stock User,Użytkownik magazynu,
+Fiscal Year Company,Rok podatkowy firmy,
+Debit Amount,Kwota Debit,
+Credit Amount,Kwota kredytu,
+Debit Amount in Account Currency,Kwota debetową w walucie rachunku,
+Credit Amount in Account Currency,Kwota kredytu w walucie rachunku,
+Voucher Detail No,Nr Szczegółu Bonu,
+Is Opening,Otwiera się,
+Is Advance,Zaawansowany proces,
+To Rename,Aby zmienić nazwę,
+GST Account,Konto GST,
+CGST Account,Konto CGST,
+SGST Account,Konto SGST,
+IGST Account,Konto IGST,
+CESS Account,Konto CESS,
+Loan Start Date,Data rozpoczęcia pożyczki,
+Loan Period (Days),Okres pożyczki (dni),
+Loan End Date,Data zakończenia pożyczki,
+Bank Charges,Opłaty bankowe,
+Short Term Loan Account,Konto pożyczki krótkoterminowej,
+Bank Charges Account,Rachunek opłat bankowych,
+Accounts Receivable Credit Account,Rachunek kredytowy należności,
+Accounts Receivable Discounted Account,Konto z rabatem należności,
+Accounts Receivable Unpaid Account,Niezapłacone konto należności,
+Item Tax Template,Szablon podatku od towarów,
+Tax Rates,Wysokość podatków,
+Item Tax Template Detail,Szczegóły szablonu podatku od towarów,
+Entry Type,Rodzaj wpisu,
+Inter Company Journal Entry,Dziennik firmy Inter Company,
+Bank Entry,Operacja bankowa,
+Cash Entry,Wpis gotówkowy,
+Credit Card Entry,Karta kredytowa,
+Contra Entry,Odpis aktualizujący,
+Excise Entry,Akcyza Wejścia,
+Write Off Entry,Odpis,
+Opening Entry,Wpis początkowy,
+ACC-JV-.YYYY.-,ACC-JV-.RRRR.-,
+Accounting Entries,Zapisy księgowe,
+Total Debit,Całkowita kwota debetu,
+Total Credit,Całkowita kwota kredytu,
+Difference (Dr - Cr),Różnica (Dr - Cr),
+Make Difference Entry,Wprowadź różnicę,
+Total Amount Currency,Suma Waluta Kwota,
+Total Amount in Words,Wartość całkowita słownie,
+Remark,Uwaga,
+Paid Loan,Płatna pożyczka,
+Inter Company Journal Entry Reference,Wpis w dzienniku firmy Inter Company,
+Write Off Based On,Odpis bazowano na,
+Get Outstanding Invoices,Uzyskaj zaległą fakturę,
+Write Off Amount,Kwota odpisu,
+Printing Settings,Ustawienia drukowania,
+Pay To / Recd From,Zapłać / Rachunek od,
+Payment Order,Zlecenie płatnicze,
+Subscription Section,Sekcja subskrypcji,
+Journal Entry Account,Konto zapisu,
+Account Balance,Bilans konta,
+Party Balance,Bilans Grupy,
+Accounting Dimensions,Wymiary księgowe,
+If Income or Expense,Jeśli przychód lub koszt,
+Exchange Rate,Kurs wymiany,
+Debit in Company Currency,Debet w firmie Waluta,
+Credit in Company Currency,Kredyt w walucie Spółki,
+Payroll Entry,Wpis o płace,
+Employee Advance,Advance pracownika,
+Reference Due Date,Referencyjny termin płatności,
+Loyalty Program Tier,Poziom programu lojalnościowego,
+Redeem Against,Zrealizuj przeciw,
+Expiry Date,Data ważności,
+Loyalty Point Entry Redemption,Punkt wejścia do punktu lojalnościowego,
+Redemption Date,Data wykupu,
+Redeemed Points,Wykorzystane punkty,
+Loyalty Program Name,Nazwa programu lojalnościowego,
+Loyalty Program Type,Typ programu lojalnościowego,
+Single Tier Program,Program dla jednego poziomu,
+Multiple Tier Program,Program wielopoziomowy,
+Customer Territory,Terytorium klienta,
+Auto Opt In (For all customers),Automatyczne optowanie (dla wszystkich klientów),
+Collection Tier,Poziom kolekcji,
+Collection Rules,Zasady zbierania,
+Redemption,Odkupienie,
+Conversion Factor,Współczynnik konwersji,
+1 Loyalty Points = How much base currency?,1 punkty lojalnościowe = ile waluty bazowej?,
+Expiry Duration (in days),Okres ważności (w dniach),
+Help Section,Sekcja pomocy,
+Loyalty Program Help,Pomoc programu lojalnościowego,
+Loyalty Program Collection,Kolekcja programu lojalnościowego,
+Tier Name,Nazwa warstwy,
+Minimum Total Spent,Minimalna łączna kwota wydana,
+Collection Factor (=1 LP),Współczynnik zbierania (= 1 LP),
+For how much spent = 1 Loyalty Point,Za ile zużytego = 1 punkt lojalnościowy,
+Mode of Payment Account,Konto księgowe dla tego rodzaju płatności,
+Default Account,Domyślne konto,
+Default account will be automatically updated in POS Invoice when this mode is selected.,Domyślne konto zostanie automatycznie zaktualizowane na fakturze POS po wybraniu tego trybu.,
+**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"** Miesięczna Dystrybucja ** pomaga rozłożyć budżet/cel w miesiącach, jeśli masz okresowość w firmie.",
+Distribution Name,Nazwa Dystrybucji,
+Name of the Monthly Distribution,Nazwa dystrybucji miesięcznej,
+Monthly Distribution Percentages,Miesięczne Procenty Dystrybucja,
+Monthly Distribution Percentage,Miesięczny rozkład procentowy,
+Percentage Allocation,Przydział Procentowy,
+Create Missing Party,Utwórz brakującą imprezę,
+Create missing customer or supplier.,Utwórz brakującego klienta lub dostawcę.,
+Opening Invoice Creation Tool Item,Otwieranie narzędzia tworzenia faktury,
+Temporary Opening Account,Tymczasowe konto otwarcia,
+Party Account,Konto Grupy,
+Type of Payment,Rodzaj płatności,
+ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-,
+Receive,Odbierać,
+Internal Transfer,Transfer wewnętrzny,
+Payment Order Status,Status zlecenia płatniczego,
+Payment Ordered,Płatność zamówiona,
+Payment From / To,Płatność Od / Do,
+Company Bank Account,Konto bankowe firmy,
+Party Bank Account,Party Bank Account,
+Account Paid From,Konto do płatności,
+Account Paid To,Konto do zapłaty,
+Paid Amount (Company Currency),Zapłacona kwota (waluta firmy),
+Received Amount,Kwota otrzymana,
+Received Amount (Company Currency),Otrzymaną kwotą (Spółka waluty),
+Get Outstanding Invoice,Uzyskaj wyjątkową fakturę,
+Payment References,Odniesienia płatności,
+Writeoff,Writeoff,
+Total Allocated Amount,Łączna kwota przyznanego wsparcia,
+Total Allocated Amount (Company Currency),Łączna kwota przyznanego wsparcia (Spółka waluty),
+Set Exchange Gain / Loss,Ustaw Exchange Zysk / strata,
+Difference Amount (Company Currency),Różnica Kwota (waluta firmy),
+Write Off Difference Amount,Różnica Kwota odpisuje,
+Deductions or Loss,Odliczenia lub strata,
+Payment Deductions or Loss,Odliczenia płatności lub strata,
+Cheque/Reference Date,Czek / Reference Data,
+Payment Entry Deduction,Płatność Wejście Odliczenie,
+Payment Entry Reference,Wejście Płatność referencyjny,
+Allocated,Przydzielone,
+Payment Gateway Account,Płatność konto Brama,
+Payment Account,Konto Płatność,
+Default Payment Request Message,Domyślnie Płatność Zapytanie Wiadomość,
+PMO-,PMO-,
+Payment Order Type,Typ zlecenia płatniczego,
+Payment Order Reference,Referencje dotyczące płatności,
+Bank Account Details,Szczegóły konta bankowego,
+Payment Reconciliation,Uzgodnienie płatności,
+Receivable / Payable Account,Konto Należności / Zobowiązań,
+Bank / Cash Account,Rachunek Bankowy/Kasowy,
+From Invoice Date,Od daty faktury,
+To Invoice Date,Aby Data faktury,
+Minimum Invoice Amount,Minimalna kwota faktury,
+Maximum Invoice Amount,Maksymalna kwota faktury,
+System will fetch all the entries if limit value is zero.,"System pobierze wszystkie wpisy, jeśli wartość graniczna wynosi zero.",
+Get Unreconciled Entries,Pobierz Wpisy nieuzgodnione,
+Unreconciled Payment Details,Szczegóły płatności nieuzgodnione,
+Invoice/Journal Entry Details,Szczegóły Faktury / Wpisu dziennika,
+Payment Reconciliation Invoice,Płatność Wyrównawcza Faktury,
+Invoice Number,Numer faktury,
+Payment Reconciliation Payment,Płatność Wyrównawcza Płatności,
+Reference Row,Odniesienie Row,
+Allocated amount,Przyznana kwota,
+Payment Request Type,Typ żądania płatności,
+Outward,Zewnętrzny,
+Inward,Wewnętrzny,
+ACC-PRQ-.YYYY.-,ACC-PRQ-.RRRR.-,
+Transaction Details,szczegóły transakcji,
+Amount in customer's currency,Kwota w walucie klienta,
+Is a Subscription,Jest subskrypcją,
+Transaction Currency,walucie transakcji,
+Subscription Plans,Plany subskrypcji,
+SWIFT Number,Numer SWIFT,
+Recipient Message And Payment Details,Odbiorca wiadomości i szczegóły płatności,
+Make Sales Invoice,Nowa faktura sprzedaży,
+Mute Email,Wyciszenie email,
+payment_url,payment_url,
+Payment Gateway Details,Payment Gateway Szczegóły,
+Payment Schedule,Harmonogram płatności,
+Invoice Portion,Fragment faktury,
+Payment Amount,Kwota płatności,
+Payment Term Name,Nazwa terminu płatności,
+Due Date Based On,Termin wykonania oparty na,
+Day(s) after invoice date,Dzień (dni) po dacie faktury,
+Day(s) after the end of the invoice month,Dzień (dni) po zakończeniu miesiąca faktury,
+Month(s) after the end of the invoice month,Miesiąc (y) po zakończeniu miesiąca faktury,
+Credit Months,Miesiące kredytowe,
+Allocate Payment Based On Payment Terms,Przydziel płatność na podstawie warunków płatności,
+"If this checkbox is checked, paid amount will be splitted and allocated as per the amounts in payment schedule against each payment term","Jeśli to pole wyboru jest zaznaczone, zapłacona kwota zostanie podzielona i przydzielona zgodnie z kwotami w harmonogramie płatności dla każdego terminu płatności",
+Payment Terms Template Detail,Warunki płatności Szczegóły szablonu,
+Closing Fiscal Year,Zamknięcie roku fiskalnego,
+"The account head under Liability or Equity, in which Profit/Loss will be booked","Głowica konto ramach odpowiedzialności lub kapitałowe, w których zysk / strata będzie zarezerwowane",
+POS Customer Group,POS Grupa klientów,
+POS Field,Pole POS,
+POS Item Group,POS Pozycja Grupy,
+Company Address,adres spółki,
+Update Stock,Aktualizuj Stan,
+Ignore Pricing Rule,Ignoruj zasadę ustalania cen,
+Applicable for Users,Dotyczy użytkowników,
+Sales Invoice Payment,Faktura sprzedaży Płatność,
+Item Groups,Pozycja Grupy,
+Only show Items from these Item Groups,Pokazuj tylko przedmioty z tych grup przedmiotów,
+Customer Groups,Grupy klientów,
+Only show Customer of these Customer Groups,Pokazuj tylko klientów tych grup klientów,
+Write Off Account,Konto Odpisu,
+Write Off Cost Center,Centrum Kosztów Odpisu,
+Account for Change Amount,Konto dla zmiany kwoty,
+Taxes and Charges,Podatki i opłaty,
+Apply Discount On,Zastosuj RABAT,
+POS Profile User,Użytkownik profilu POS,
+Apply On,Zastosuj Na,
+Price or Product Discount,Rabat na cenę lub produkt,
+Apply Rule On Item Code,Zastosuj regułę do kodu towaru,
+Apply Rule On Item Group,Zastosuj regułę dla grupy pozycji,
+Apply Rule On Brand,Zastosuj regułę do marki,
+Mixed Conditions,Warunki mieszane,
+Conditions will be applied on all the selected items combined. ,Warunki zostaną zastosowane do wszystkich wybranych elementów łącznie.,
+Is Cumulative,Jest kumulatywny,
+Coupon Code Based,Na podstawie kodu kuponu,
+Discount on Other Item,Rabat na inny przedmiot,
+Apply Rule On Other,Zastosuj regułę do innych,
+Party Information,Informacje o imprezie,
+Quantity and Amount,Ilość i kwota,
+Min Qty,Min. ilość,
+Max Qty,Maks. Ilość,
+Min Amt,Min Amt,
+Max Amt,Max Amt,
+Period Settings,Ustawienia okresu,
+Margin Type,margines Rodzaj,
+Margin Rate or Amount,Margines szybkości lub wielkości,
+Price Discount Scheme,System rabatów cenowych,
+Rate or Discount,Stawka lub zniżka,
+Discount Percentage,Procent zniżki,
+Discount Amount,Wartość zniżki,
+For Price List,Dla Listy Cen,
+Product Discount Scheme,Program rabatów na produkty,
+Same Item,Ten sam przedmiot,
+Free Item,Bezpłatny przedmiot,
+Threshold for Suggestion,Próg dla sugestii,
+System will notify to increase or decrease quantity or amount ,System powiadomi o zwiększeniu lub zmniejszeniu ilości lub ilości,
+"Higher the number, higher the priority","Im wyższa liczba, wyższy priorytet",
+Apply Multiple Pricing Rules,Zastosuj wiele zasad ustalania cen,
+Apply Discount on Rate,Zastosuj zniżkę na stawkę,
+Validate Applied Rule,Sprawdź poprawność zastosowanej reguły,
+Rule Description,Opis reguły,
+Pricing Rule Help,Pomoc dotycząca ustalania cen,
+Promotional Scheme Id,Program promocyjny Id,
+Promotional Scheme,Program promocyjny,
+Pricing Rule Brand,Zasady ustalania ceny marki,
+Pricing Rule Detail,Szczegóły reguły cenowej,
+Child Docname,Nazwa dziecka,
+Rule Applied,Stosowana reguła,
+Pricing Rule Item Code,Kod pozycji reguły cenowej,
+Pricing Rule Item Group,Grupa pozycji Reguły cenowe,
+Price Discount Slabs,Płyty z rabatem cenowym,
+Promotional Scheme Price Discount,Zniżka cenowa programu promocyjnego,
+Product Discount Slabs,Płyty z rabatem na produkty,
+Promotional Scheme Product Discount,Rabat na program promocyjny,
+Min Amount,Min. Kwota,
+Max Amount,Maksymalna kwota,
+Discount Type,Typ rabatu,
+ACC-PINV-.YYYY.-,ACC-PINV-.RRRR.-,
+Tax Withholding Category,Kategoria odwrotnego obciążenia,
+Edit Posting Date and Time,Zmodyfikuj datę i czas dokumentu,
+Is Paid,Zapłacone,
+Is Return (Debit Note),Jest zwrotem (nota debetowa),
+Apply Tax Withholding Amount,Zastosuj kwotę podatku u źródła,
+Accounting Dimensions ,Wymiary księgowe,
+Supplier Invoice Details,Dostawca Szczegóły faktury,
+Supplier Invoice Date,Data faktury dostawcy,
+Return Against Purchase Invoice,Powrót Against dowodu zakupu,
+Select Supplier Address,Wybierz adres dostawcy,
+Contact Person,Osoba kontaktowa,
+Select Shipping Address,Wybierz adres dostawy,
+Currency and Price List,Waluta i cennik,
+Price List Currency,Waluta cennika,
+Price List Exchange Rate,Cennik Kursowy,
+Set Accepted Warehouse,Ustaw przyjęty magazyn,
+Rejected Warehouse,Odrzucony Magazyn,
+Warehouse where you are maintaining stock of rejected items,Magazyn w którym zarządzasz odrzuconymi przedmiotami,
+Raw Materials Supplied,Dostarczone surowce,
+Supplier Warehouse,Magazyn dostawcy,
+Pricing Rules,Zasady ustalania cen,
+Supplied Items,Dostarczone przedmioty,
+Total (Company Currency),Razem (Spółka Waluta),
+Net Total (Company Currency),Łączna wartość netto (waluta firmy),
+Total Net Weight,Całkowita waga netto,
+Shipping Rule,Zasada dostawy,
+Purchase Taxes and Charges Template,Szablon podatków i opłat związanych z zakupami,
+Purchase Taxes and Charges,Podatki i opłaty kupna,
+Tax Breakup,Podział podatków,
+Taxes and Charges Calculation,Obliczanie podatków i opłat,
+Taxes and Charges Added (Company Currency),Dodano podatki i opłaty (Firmowe),
+Taxes and Charges Deducted (Company Currency),Podatki i opłaty potrącone (Firmowe),
+Total Taxes and Charges (Company Currency),Łączna kwota podatków i opłat (wg Firmy),
+Taxes and Charges Added,Dodano podatki i opłaty,
+Taxes and Charges Deducted,Podatki i opłaty potrącenia,
+Total Taxes and Charges,Łączna kwota podatków i opłat,
+Additional Discount,Dodatkowe Zniżki,
+Apply Additional Discount On,Zastosuj dodatkowe zniżki na,
+Additional Discount Amount (Company Currency),Dodatkowa kwota rabatu (waluta firmy),
+Additional Discount Percentage,Dodatkowy procent rabatu,
+Additional Discount Amount,Dodatkowa kwota rabatu,
+Grand Total (Company Currency),Całkowita suma (w walucie firmy),
+Rounding Adjustment (Company Currency),Korekta zaokrąglenia (waluta firmy),
+Rounded Total (Company Currency),Końcowa zaokrąglona kwota (waluta firmy),
+In Words (Company Currency),Słownie,
+Rounding Adjustment,Dopasowanie zaokrąglania,
+In Words,Słownie,
+Total Advance,Całość zaliczka,
+Disable Rounded Total,Wyłącz Zaokrąglanie Sumy,
+Cash/Bank Account,Konto Gotówka / Bank,
+Write Off Amount (Company Currency),Kwota Odpisu (Waluta Firmy),
+Set Advances and Allocate (FIFO),Ustaw Advances and Allocate (FIFO),
+Get Advances Paid,Uzyskaj opłacone zaliczki,
+Advances,Zaliczki,
+Terms,Warunki,
+Terms and Conditions1,Warunki1,
+Group same items,Grupa same pozycje,
+Print Language,Język drukowania,
+"Once set, this invoice will be on hold till the set date",Po ustawieniu faktura ta będzie zawieszona do wyznaczonej daty,
+Credit To,Kredytowane konto (Ma),
+Party Account Currency,Partia konto Waluta,
+Against Expense Account,Konto wydatków,
+Inter Company Invoice Reference,Numer referencyjny faktury firmy,
+Is Internal Supplier,Dostawca wewnętrzny,
+Start date of current invoice's period,Początek okresu rozliczeniowego dla faktury,
+End date of current invoice's period,Data zakończenia okresu bieżącej faktury,
+Update Auto Repeat Reference,Zaktualizuj Auto Repeat Reference,
+Purchase Invoice Advance,Wyślij Fakturę Zaliczkową / Proformę,
+Purchase Invoice Item,Przedmiot Faktury Zakupu,
+Quantity and Rate,Ilość i Wskaźnik,
+Received Qty,Otrzymana ilość,
+Accepted Qty,Akceptowana ilość,
+Rejected Qty,odrzucony szt,
+UOM Conversion Factor,Współczynnik konwersji jednostki miary,
+Discount on Price List Rate (%),Zniżka Cennik Oceń (%),
+Price List Rate (Company Currency),Wartość w cenniku (waluta firmy),
+Rate ,Stawka,
+Rate (Company Currency),Stawka (waluta firmy),
+Amount (Company Currency),Kwota (Waluta firmy),
+Is Free Item,Jest darmowym przedmiotem,
+Net Rate,Cena netto,
+Net Rate (Company Currency),Cena netto (Spółka Waluta),
+Net Amount (Company Currency),Kwota netto (Waluta Spółki),
+Item Tax Amount Included in Value,Pozycja Kwota podatku zawarta w wartości,
+Landed Cost Voucher Amount,Kwota Kosztu Voucheru,
+Raw Materials Supplied Cost,Koszt dostarczonych surowców,
+Accepted Warehouse,Przyjęty magazyn,
+Serial No,Nr seryjny,
+Rejected Serial No,Odrzucony Nr Seryjny,
+Expense Head,Szef Wydatków,
+Is Fixed Asset,Czy trwałego,
+Asset Location,Lokalizacja zasobów,
+Deferred Expense,Odroczony koszt,
+Deferred Expense Account,Rachunek odroczonego obciążenia,
+Service Stop Date,Data zatrzymania usługi,
+Enable Deferred Expense,Włącz odroczony koszt,
+Service Start Date,Data rozpoczęcia usługi,
+Service End Date,Data zakończenia usługi,
+Allow Zero Valuation Rate,Zezwalaj na zerową wartość wyceny,
+Item Tax Rate,Stawka podatku dla tej pozycji,
+Tax detail table fetched from item master as a string and stored in this field.\nUsed for Taxes and Charges,Podatki pobierane z tabeli szczegółów mistrza poz jako ciąg znaków i przechowywane w tej dziedzinie.\n Służy do podatkach i opłatach,
+Purchase Order Item,Przedmiot Zamówienia Kupna,
+Purchase Receipt Detail,Szczegóły zakupu paragonu,
+Item Weight Details,Szczegóły dotyczące wagi przedmiotu,
+Weight Per Unit,Waga na jednostkę,
+Total Weight,Waga całkowita,
+Weight UOM,Waga jednostkowa,
+Page Break,Znak końca strony,
+Consider Tax or Charge for,Rozwać Podatek albo Opłatę za,
+Valuation and Total,Wycena i kwota całkowita,
+Valuation,Wycena,
+Add or Deduct,Dodatki lub Potrącenia,
+Deduct,Odlicz,
+On Item Quantity,Na ilość przedmiotu,
+Reference Row #,Rząd Odniesienia #,
+Is this Tax included in Basic Rate?,Czy podatek wliczony jest w opłaty?,
+"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Jeśli zaznaczone, kwota podatku zostanie wliczona w cenie Drukuj Cenę / Drukuj Podsumowanie",
+Account Head,Konto główne,
+Tax Amount After Discount Amount,Kwota podatku po odliczeniu wysokości rabatu,
+Item Wise Tax Detail ,Mądre informacje podatkowe dotyczące przedmiotu,
+"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.\n10. Add or Deduct: Whether you want to add or deduct the tax.","Standardowy szablon podatek, który może być stosowany do wszystkich transakcji kupna. Ten szablon może zawierać listę szefów podatkowych, a także innych głów wydatków jak ""Żegluga"", ""Ubezpieczenia"", ""Obsługa"" itp \n\n #### Uwaga \n\n stawki podatku zdefiniować tutaj będzie standardowa stawka podatku w odniesieniu do wszystkich pozycji ** **. Jeśli istnieją ** Pozycje **, które mają różne ceny, muszą być dodane w podatku od towaru ** ** tabeli w poz ** ** mistrza.\n\n #### Opis Kolumny \n\n 1. Obliczenie Typ: \n i - może to być na całkowita ** ** (to jest suma ilości wyjściowej).\n - ** Na Poprzedni Row Całkowita / Kwota ** (dla skumulowanych podatków lub opłat). Jeśli wybierzesz tę opcję, podatek będzie stosowana jako procent poprzedniego rzędu (w tabeli podatkowej) kwoty lub łącznie.\n - ** Rzeczywista ** (jak wspomniano).\n 2. Szef konta: księga konto, na którym podatek ten zostanie zaksięgowany \n 3. Centrum koszt: Jeżeli podatek / opłata jest dochód (jak wysyłką) lub kosztów musi zostać zaliczony na centrum kosztów.\n 4. Opis: Opis podatków (które będą drukowane w faktur / cudzysłowów).\n 5. Cena: Stawka podatku.\n 6. Kwota: Kwota podatku.\n 7. Razem: Zbiorcza sumie do tego punktu.\n 8. Wprowadź Row: Jeśli na podstawie ""Razem poprzedniego wiersza"" można wybrać numer wiersza, które będą brane jako baza do tego obliczenia (domyślnie jest to poprzednia wiersz).\n 9. Zastanów podatek lub opłatę za: W tej sekcji można określić, czy podatek / opłata jest tylko dla wyceny (nie jest częścią całości) lub tylko dla całości (nie dodaje wartości do elementu) lub oba.\n 10. Dodać lub odjąć: Czy chcesz dodać lub odjąć podatek.",
+Salary Component Account,Konto Wynagrodzenie Komponent,
+Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Domyślne konto bank / bankomat zostanie automatycznie zaktualizowana wynagrodzenia Journal Entry po wybraniu tego trybu.,
+ACC-SINV-.YYYY.-,ACC-SINV-.RRRR.-,
+Include Payment (POS),Obejmują płatności (POS),
+Offline POS Name,Offline POS Nazwa,
+Is Return (Credit Note),Jest zwrot (nota kredytowa),
+Return Against Sales Invoice,Powrót Against faktury sprzedaży,
+Update Billed Amount in Sales Order,Zaktualizuj kwotę rozliczenia w zleceniu sprzedaży,
+Customer PO Details,Szczegóły zamówienia klienta,
+Customer's Purchase Order,Klienta Zamówienia,
+Customer's Purchase Order Date,Data Zamówienia Zakupu Klienta,
+Customer Address,Adres klienta,
+Shipping Address Name,Adres do wysyłki Nazwa,
+Company Address Name,Nazwa firmy,
+Rate at which Customer Currency is converted to customer's base currency,Stawka przy użyciu której Waluta Klienta jest konwertowana do podstawowej waluty klienta,
+Rate at which Price list currency is converted to customer's base currency,Stawka przy użyciu której waluta Listy Cen jest konwertowana do podstawowej waluty klienta,
+Set Source Warehouse,Ustaw magazyn źródłowy,
+Packing List,Lista przedmiotów do spakowania,
+Packed Items,Przedmioty pakowane,
+Product Bundle Help,Produkt Bundle Pomoc,
+Time Sheet List,Czas Lista Sheet,
+Time Sheets,arkusze czasu,
+Total Billing Amount,Łączna kwota płatności,
+Sales Taxes and Charges Template,Podatki od sprzedaży i opłaty Szablon,
+Sales Taxes and Charges,Podatki i Opłaty od Sprzedaży,
+Loyalty Points Redemption,Odkupienie punktów lojalnościowych,
+Redeem Loyalty Points,Wykorzystaj punkty lojalnościowe,
+Redemption Account,Rachunek wykupu,
+Redemption Cost Center,Centrum kosztów odkupienia,
+In Words will be visible once you save the Sales Invoice.,"Słownie, będzie widoczne w fakturze sprzedaży, po zapisaniu",
+Allocate Advances Automatically (FIFO),Automatycznie przydzielaj zaliczki (FIFO),
+Get Advances Received,Uzyskaj otrzymane zaliczki,
+Base Change Amount (Company Currency),Kwota bazowa Change (Spółka waluty),
+Write Off Outstanding Amount,Nieuregulowana Wartość Odpisu,
+Terms and Conditions Details,Szczegóły regulaminu,
+Is Internal Customer,Jest klientem wewnętrznym,
+Is Discounted,Jest dyskontowany,
+Unpaid and Discounted,Nieopłacone i zniżki,
+Overdue and Discounted,Zaległe i zdyskontowane,
+Accounting Details,Dane księgowe,
+Debit To,Debetowane Konto (Winien),
+Commission Rate (%),Wartość prowizji (%),
+Sales Team1,Team Sprzedażowy1,
+Against Income Account,Konto przychodów,
+Sales Invoice Advance,Faktura Zaliczkowa,
+Advance amount,Kwota Zaliczki,
+Sales Invoice Item,Przedmiot Faktury Sprzedaży,
+Customer's Item Code,Kod Przedmiotu Klienta,
+Brand Name,Nazwa Marki,
+Qty as per Stock UOM,Ilość wg. Jednostki Miary,
+Discount and Margin,Rabat i marży,
+Rate With Margin,Rate With Margin,
+Discount (%) on Price List Rate with Margin,Zniżka (%) w Tabeli Cen Ceny z Marginesem,
+Rate With Margin (Company Currency),Stawka z depozytem zabezpieczającym (waluta spółki),
+Delivered By Supplier,Dostarczane przez Dostawcę,
+Deferred Revenue,Odroczone przychody,
+Deferred Revenue Account,Konto odroczonego przychodu,
+Enable Deferred Revenue,Włącz odroczone przychody,
+Stock Details,Zdjęcie Szczegóły,
+Customer Warehouse (Optional),Magazyn klienta (opcjonalnie),
+Available Batch Qty at Warehouse,Dostępne w Warehouse partii Ilość,
+Available Qty at Warehouse,Ilość dostępna w magazynie,
+Delivery Note Item,Przedmiot z dowodu dostawy,
+Base Amount (Company Currency),Kwota bazowa (Waluta firmy),
+Sales Invoice Timesheet,Faktura sprzedaży grafiku,
+Time Sheet,Czas Sheet,
+Billing Hours,Godziny billingowe,
+Timesheet Detail,Szczegółowy grafik,
+Tax Amount After Discount Amount (Company Currency),Kwota podatku po uwzględnieniu rabatu (waluta firmy),
+Parenttype,Typ Nadrzędności,
+"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","Standardowy szablon podatek, który może być stosowany do wszystkich transakcji sprzedaży. Ten szablon może zawierać listę szefów podatkowych, a także innych głów koszty / dochodów jak ""Żegluga"", ""Ubezpieczenia"", ""Obsługa"" itp \n\n #### Uwaga \n\n Stopa Ciebie podatku definiujemy tu będzie standardowa stawka podatku w odniesieniu do wszystkich pozycji ** **. Jeśli istnieją ** Pozycje **, które mają różne ceny, muszą być dodane w podatku od towaru ** ** tabeli w poz ** ** mistrza.\n\n #### Opis Kolumny \n\n 1. Obliczenie Typ: \n i - może to być na całkowita ** ** (to jest suma ilości wyjściowej).\n - ** Na Poprzedni Row Całkowita / Kwota ** (dla skumulowanych podatków lub opłat). Jeśli wybierzesz tę opcję, podatek będzie stosowana jako procent poprzedniego rzędu (w tabeli podatkowej) kwoty lub łącznie.\n - ** Rzeczywista ** (jak wspomniano).\n 2. Szef konta: księga konto, na którym podatek ten zostanie zaksięgowany \n 3. Centrum koszt: Jeżeli podatek / opłata jest dochód (jak wysyłką) lub kosztów musi zostać zaliczony na centrum kosztów.\n 4. Opis: Opis podatków (które będą drukowane w faktur / cudzysłowów).\n 5. Cena: Stawka podatku.\n 6. Kwota: Kwota podatku.\n 7. Razem: Zbiorcza sumie do tego punktu.\n 8. Wprowadź Row: Jeśli na podstawie ""Razem poprzedniego wiersza"" można wybrać numer wiersza, które będą brane jako baza do tego obliczenia (domyślnie jest to poprzednia wiersz).\n 9. Czy to podatki zawarte w podstawowej stawki ?: Jeśli to sprawdzić, oznacza to, że podatek ten nie będzie wyświetlany pod tabelą pozycji, ale będą włączone do stawki podstawowej w głównej tabeli poz. Jest to przydatne, gdy chcesz dać cenę mieszkania (z uwzględnieniem wszystkich podatków) cenę do klientów.",
+* Will be calculated in the transaction.,* Zostanie policzony dla transakcji.,
+From No,Od Nie,
+To No,Do Nie,
+Is Company,Czy firma,
+Current State,Stan aktulany,
+Purchased,Zakupione,
+From Shareholder,Od Akcjonariusza,
+From Folio No,Z Folio nr,
+To Shareholder,Do Akcjonariusza,
+To Folio No,Do Folio Nie,
+Equity/Liability Account,Rachunek akcyjny / zobowiązanie,
+Asset Account,Konto aktywów,
+(including),(włącznie z),
+ACC-SH-.YYYY.-,ACC-SH-.RRRR.-,
+Folio no.,Numer folio,
+Address and Contacts,Adres i kontakty,
+Contact List,Lista kontaktów,
+Hidden list maintaining the list of contacts linked to Shareholder,Ukryta lista z listą kontaktów powiązanych z Akcjonariuszem,
+Specify conditions to calculate shipping amount,Określ warunki do obliczenia kwoty wysyłki,
+Shipping Rule Label,Etykieta z zasadami wysyłki i transportu,
+example: Next Day Shipping,przykład: Wysyłka następnego dnia,
+Shipping Rule Type,Typ reguły wysyłki,
+Shipping Account,Konto dostawy,
+Calculate Based On,Obliczone na podstawie,
+Fixed,Naprawiony,
+Net Weight,Waga netto,
+Shipping Amount,Ilość dostawy,
+Shipping Rule Conditions,Warunki zasady dostawy,
+Restrict to Countries,Ogranicz do krajów,
+Valid for Countries,Ważny dla krajów,
+Shipping Rule Condition,Warunek zasady dostawy,
+A condition for a Shipping Rule,Warunki wysyłki,
+From Value,Od wartości,
+To Value,Określ wartość,
+Shipping Rule Country,Zasada Wysyłka Kraj,
+Subscription Period,Okres subskrypcji,
+Subscription Start Date,Data rozpoczęcia subskrypcji,
+Cancelation Date,Data Anulowania,
+Trial Period Start Date,Data rozpoczęcia okresu próbnego,
+Trial Period End Date,Termin zakończenia okresu próbnego,
+Current Invoice Start Date,Aktualna data rozpoczęcia faktury,
+Current Invoice End Date,Aktualna data zakończenia faktury,
+Days Until Due,Dni do końca,
+Number of days that the subscriber has to pay invoices generated by this subscription,"Liczba dni, w których subskrybent musi płacić faktury wygenerowane w ramach tej subskrypcji",
+Cancel At End Of Period,Anuluj na koniec okresu,
+Generate Invoice At Beginning Of Period,Wygeneruj fakturę na początku okresu,
+Plans,Plany,
+Discounts,Rabaty,
+Additional DIscount Percentage,Dodatkowy rabat procentowy,
+Additional DIscount Amount,Kwota dodatkowego rabatu,
+Subscription Invoice,Faktura subskrypcyjna,
+Subscription Plan,Abonament abonamentowy,
+Cost,Koszt,
+Billing Interval,Okres rozliczeniowy,
+Billing Interval Count,Liczba interwałów rozliczeń,
+"Number of intervals for the interval field e.g if Interval is 'Days' and Billing Interval Count is 3, invoices will be generated every 3 days","Liczba interwałów dla pola interwałowego, np. Jeśli Interwał to &quot;Dni&quot;, a liczba interwałów rozliczeń to 3, faktury będą generowane co 3 dni",
+Payment Plan,Plan płatności,
+Subscription Plan Detail,Szczegóły abonamentu,
+Plan,Plan,
+Subscription Settings,Ustawienia subskrypcji,
+Grace Period,Okres łaski,
+Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,Liczba dni po dacie faktury upłynęła przed anulowaniem subskrypcji lub oznaczenia subskrypcji jako niepłatne,
+Prorate,Prorate,
+Tax Rule,Reguła podatkowa,
+Tax Type,Rodzaj podatku,
+Use for Shopping Cart,Służy do koszyka,
+Billing City,Rozliczenia Miasto,
+Billing County,Powiat,
+Billing State,Stan Billing,
+Billing Zipcode,Kod pocztowy do rozliczeń,
+Billing Country,Kraj fakturowania,
+Shipping City,Wysyłka Miasto,
+Shipping County,Dostawa County,
+Shipping State,Stan zakupu,
+Shipping Zipcode,Kod pocztowy wysyłki,
+Shipping Country,Wysyłka Kraj,
+Tax Withholding Account,Rachunek potrącenia podatku u źródła,
+Tax Withholding Rates,Podatki potrącane u źródła,
+Rates,Stawki,
+Tax Withholding Rate,Podatek u źródła,
+Single Transaction Threshold,Próg pojedynczej transakcji,
+Cumulative Transaction Threshold,Skumulowany próg transakcji,
+Agriculture Analysis Criteria,Kryteria analizy rolnictwa,
+Linked Doctype,Połączony Doctype,
+Water Analysis,Analiza wody,
+Soil Analysis,Analiza gleby,
+Plant Analysis,Analiza roślin,
+Fertilizer,Nawóz,
+Soil Texture,Tekstura gleby,
+Weather,Pogoda,
+Agriculture Manager,Dyrektor ds. Rolnictwa,
+Agriculture User,Użytkownik rolnictwa,
+Agriculture Task,Zadanie rolnicze,
+Task Name,Nazwa zadania,
+Start Day,Rozpocząć dzień,
+End Day,Koniec dnia,
+Holiday Management,Zarządzanie wakacjami,
+Ignore holidays,Ignoruj święta,
+Previous Business Day,Poprzedni dzień roboczy,
+Next Business Day,Następny dzień roboczy,
+Urgent,Pilne,
+Crop,Przyciąć,
+Crop Name,Nazwa uprawy,
+Scientific Name,Nazwa naukowa,
+"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Możesz tu zdefiniować wszystkie zadania, które należy wykonać dla tego zbioru. Pole dnia jest używane do wskazania dnia, w którym należy wykonać zadanie, 1 oznacza pierwszy dzień itd.",
+Crop Spacing,Odstępy między plamami,
+Crop Spacing UOM,Odstępy między plamami UOM,
+Row Spacing,Rozstaw wierszy,
+Row Spacing UOM,Rozstaw rzędów UOM,
+Perennial,Bylina,
+Biennial,Dwuletni,
+Planting UOM,Sadzenie MOM,
+Planting Area,Obszar sadzenia,
+Yield UOM,Wydajność UOM,
+Materials Required,Wymagane materiały,
+Produced Items,Produkowane przedmioty,
+Produce,Produkować,
+Byproducts,Przez produkty,
+Linked Location,Powiązana lokalizacja,
+A link to all the Locations in which the Crop is growing,"Łącze do wszystkich lokalizacji, w których rośnie uprawa",
+This will be day 1 of the crop cycle,To będzie pierwszy dzień cyklu zbiorów,
+ISO 8601 standard,Norma ISO 8601,
+Cycle Type,Typ cyklu,
+Less than a year,Mniej niż rok,
+The minimum length between each plant in the field for optimum growth,Minimalna długość między każdą rośliną w polu dla optymalnego wzrostu,
+The minimum distance between rows of plants for optimum growth,Minimalna odległość między rzędami roślin dla optymalnego wzrostu,
+Detected Diseases,Wykryto choroby,
+List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,Lista chorób wykrytych na polu. Po wybraniu automatycznie doda listę zadań do radzenia sobie z chorobą,
+Detected Disease,Wykryto chorobę,
+LInked Analysis,Analiza LInked,
+Disease,Choroba,
+Tasks Created,Zadania utworzone,
+Common Name,Nazwa zwyczajowa,
+Treatment Task,Zadanie leczenia,
+Treatment Period,Okres leczenia,
+Fertilizer Name,Nazwa nawozu,
+Density (if liquid),Gęstość (jeśli ciecz),
+Fertilizer Contents,Zawartość nawozu,
+Fertilizer Content,Zawartość nawozu,
+Linked Plant Analysis,Połączona analiza roślin,
+Linked Soil Analysis,Powiązana analiza gleby,
+Linked Soil Texture,Połączona tekstura gleby,
+Collection Datetime,Kolekcja Datetime,
+Laboratory Testing Datetime,Testowanie laboratoryjne Datetime,
+Result Datetime,Wynik Datetime,
+Plant Analysis Criterias,Kryteria analizy roślin,
+Plant Analysis Criteria,Kryteria analizy roślin,
+Minimum Permissible Value,Minimalna dopuszczalna wartość,
+Maximum Permissible Value,Maksymalna dopuszczalna wartość,
+Ca/K,Ca / K,
+Ca/Mg,Ca / Mg,
+Mg/K,Mg / K,
+(Ca+Mg)/K,(Ca + Mg) / K,
+Ca/(K+Ca+Mg),Ca / (K + Ca + Mg),
+Soil Analysis Criterias,Kryteria analizy gleby,
+Soil Analysis Criteria,Kryteria analizy gleby,
+Soil Type,Typ gleby,
+Loamy Sand,Piasek gliniasty,
+Sandy Loam,Sandy Loam,
+Loam,Ił,
+Silt Loam,Silt Loam,
+Sandy Clay Loam,Sandy Clay Loam,
+Clay Loam,Clay Loam,
+Silty Clay Loam,Silty Clay Loam,
+Sandy Clay,Sandy Clay,
+Silty Clay,Silty Clay,
+Clay Composition (%),Skład gliny (%),
+Sand Composition (%),Skład piasku (%),
+Silt Composition (%),Skład mułu (%),
+Ternary Plot,Ternary Plot,
+Soil Texture Criteria,Kryteria tekstury gleby,
+Type of Sample,Rodzaj próbki,
+Container,Pojemnik,
+Origin,Pochodzenie,
+Collection Temperature ,Temperatura zbierania,
+Storage Temperature,Temperatura przechowywania,
+Appearance,Wygląd,
+Person Responsible,Osoba odpowiedzialna,
+Water Analysis Criteria,Kryteria analizy wody,
+Weather Parameter,Parametr pogody,
+ACC-ASS-.YYYY.-,ACC-ASS-.YYYY.-,
+Asset Owner,Właściciel zasobu,
+Asset Owner Company,Asset Owner Company,
+Custodian,Kustosz,
+Disposal Date,Utylizacja Data,
+Journal Entry for Scrap,Księgowanie na złom,
+Available-for-use Date,Data przydatności do użycia,
+Calculate Depreciation,Oblicz amortyzację,
+Allow Monthly Depreciation,Zezwalaj na miesięczną amortyzację,
+Number of Depreciations Booked,Ilość amortyzacją zarezerwowano,
+Finance Books,Finanse Książki,
+Straight Line,Linia prosta,
+Double Declining Balance,Podwójne Bilans Spadek,
+Manual,podręcznik,
+Value After Depreciation,Wartość po amortyzacji,
+Total Number of Depreciations,Całkowita liczba amortyzacją,
+Frequency of Depreciation (Months),Częstotliwość Amortyzacja (miesiące),
+Next Depreciation Date,Następny Amortyzacja Data,
+Depreciation Schedule,amortyzacja Harmonogram,
+Depreciation Schedules,Rozkłady amortyzacyjne,
+Insurance details,Szczegóły ubezpieczenia,
+Policy number,Numer polisy,
+Insurer,Ubezpieczający,
+Insured value,Wartość ubezpieczenia,
+Insurance Start Date,Data rozpoczęcia ubezpieczenia,
+Insurance End Date,Data zakończenia ubezpieczenia,
+Comprehensive Insurance,Kompleksowe ubezpieczenie,
+Maintenance Required,Wymagane czynności konserwacyjne,
+Check if Asset requires Preventive Maintenance or Calibration,"Sprawdź, czy Zasób wymaga konserwacji profilaktycznej lub kalibracji",
+Booked Fixed Asset,Zarezerwowany środek trwały,
+Purchase Receipt Amount,Kup kwotę odbioru,
+Default Finance Book,Domyślna księga finansowa,
+Quality Manager,Manager Jakości,
+Asset Category Name,Zaleta Nazwa kategorii,
+Depreciation Options,Opcje amortyzacji,
+Enable Capital Work in Progress Accounting,Włącz rachunkowość kapitału w toku,
+Finance Book Detail,Finanse Książka szczegółów,
+Asset Category Account,Konto Aktywów Kategoria,
+Fixed Asset Account,Konto trwałego,
+Accumulated Depreciation Account,Skumulowana Amortyzacja konta,
+Depreciation Expense Account,Konto amortyzacji wydatków,
+Capital Work In Progress Account,Kapitałowe konto w toku,
+Asset Finance Book,Książka o finansach aktywów,
+Written Down Value,Zapisana wartość,
+Expected Value After Useful Life,Przewidywany okres użytkowania wartości po,
+Rate of Depreciation,Stopa amortyzacji,
+In Percentage,W procentach,
+Maintenance Team,Zespół serwisowy,
+Maintenance Manager Name,Nazwa menedżera konserwacji,
+Maintenance Tasks,Zadania konserwacji,
+Manufacturing User,Produkcja użytkownika,
+Asset Maintenance Log,Dziennik konserwacji zasobów,
+ACC-AML-.YYYY.-,ACC-AML-.RRRR.-,
+Maintenance Type,Typ Konserwacji,
+Maintenance Status,Status Konserwacji,
+Planned,Zaplanowany,
+Has Certificate ,Posiada certyfikat,
+Certificate,Certyfikat,
+Actions performed,Wykonane akcje,
+Asset Maintenance Task,Zadanie utrzymania aktywów,
+Maintenance Task,Zadanie konserwacji,
+Preventive Maintenance,Konserwacja zapobiegawcza,
+Calibration,Kalibrowanie,
+2 Yearly,2 Rocznie,
+Certificate Required,Wymagany certyfikat,
+Assign to Name,Przypisz do nazwy,
+Next Due Date,Następna data płatności,
+Last Completion Date,Ostatnia data ukończenia,
+Asset Maintenance Team,Zespół ds. Utrzymania aktywów,
+Maintenance Team Name,Nazwa zespołu obsługi technicznej,
+Maintenance Team Members,Członkowie zespołu ds. Konserwacji,
+Purpose,Cel,
+Stock Manager,Kierownik magazynu,
+Asset Movement Item,Element ruchu zasobu,
+Source Location,Lokalizacja źródła,
+From Employee,Od pracownika,
+Target Location,Docelowa lokalizacja,
+To Employee,Do pracownika,
+Asset Repair,Naprawa aktywów,
+ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-,
+Failure Date,Data awarii,
+Assign To Name,Przypisywanie do nazwy,
+Repair Status,Status naprawy,
+Error Description,Opis błędu,
+Downtime,Przestój,
+Repair Cost,koszty naprawy,
+Manufacturing Manager,Kierownik Produkcji,
+Current Asset Value,Aktualna wartość aktywów,
+New Asset Value,Nowa wartość aktywów,
+Make Depreciation Entry,Bądź Amortyzacja Entry,
+Finance Book Id,Identyfikator książki finansowej,
+Location Name,Nazwa lokalizacji,
+Parent Location,Lokalizacja rodzica,
+Is Container,To kontener,
+Check if it is a hydroponic unit,"Sprawdź, czy to jednostka hydroponiczna",
+Location Details,Szczegóły lokalizacji,
+Latitude,Szerokość,
+Longitude,Długość geograficzna,
+Area,Powierzchnia,
+Area UOM,Obszar UOM,
+Tree Details,drzewo Szczegóły,
+Maintenance Team Member,Członek zespołu ds. Konserwacji,
+Team Member,Członek zespołu,
+Maintenance Role,Rola konserwacji,
+Buying Settings,Ustawienia zakupów,
+Settings for Buying Module,Ustawienia Zakup modułu,
+Supplier Naming By,Po nazwie dostawcy,
+Default Supplier Group,Domyślna grupa dostawców,
+Default Buying Price List,Domyślny cennik dla zakupów,
+Backflush Raw Materials of Subcontract Based On,Rozliczenie wsteczne materiałów podwykonawstwa,
+Material Transferred for Subcontract,Materiał przekazany do podwykonawstwa,
+Over Transfer Allowance (%),Nadwyżka limitu transferu (%),
+Percentage you are allowed to transfer more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to transfer 110 units.,"Procent, który możesz przekazać więcej w stosunku do zamówionej ilości. Na przykład: jeśli zamówiłeś 100 jednostek. a Twój zasiłek wynosi 10%, możesz przenieść 110 jednostek.",
+PUR-ORD-.YYYY.-,PUR-ORD-.YYYY.-,
+Get Items from Open Material Requests,Elementy z żądań Otwórz Materiał,
+Fetch items based on Default Supplier.,Pobierz elementy na podstawie domyślnego dostawcy.,
+Required By,Wymagane przez,
+Order Confirmation No,Potwierdzenie nr,
+Order Confirmation Date,Zamów datę potwierdzenia,
+Customer Mobile No,Komórka klienta Nie,
+Customer Contact Email,Kontakt z klientem e-mail,
+Set Target Warehouse,Ustaw magazyn docelowy,
+Sets 'Warehouse' in each row of the Items table.,Ustawia „Magazyn” w każdym wierszu tabeli Towary.,
+Supply Raw Materials,Zaopatrzenia w surowce,
+Purchase Order Pricing Rule,Reguła cenowa zamówienia zakupu,
+Set Reserve Warehouse,Ustaw Rezerwuj magazyn,
+In Words will be visible once you save the Purchase Order.,Słownie będzie widoczna w Zamówieniu po zapisaniu,
+Advance Paid,Zaliczka,
+Tracking,Śledzenie,
+% Billed,% rozliczonych,
+% Received,% Otrzymanych,
+Ref SQ,Ref SQ,
+Inter Company Order Reference,Informacje o zamówieniach między firmami,
+Supplier Part Number,Numer katalogowy dostawcy,
+Billed Amt,Rozliczona Ilość,
+Warehouse and Reference,Magazyn i punkt odniesienia,
+To be delivered to customer,Być dostarczone do klienta,
+Against Blanket Order,Przeciw Kocowi,
+Blanket Order,Formularz zamówienia,
+Blanket Order Rate,Ogólny koszt zamówienia,
+Returned Qty,Wrócił szt,
+Purchase Order Item Supplied,Dostarczony przedmiot zamówienia,
+BOM Detail No,BOM Numer,
+Stock Uom,Jednostka,
+Raw Material Item Code,Kod surowca,
+Supplied Qty,Dostarczane szt,
+Purchase Receipt Item Supplied,Rachunek Kupna Zaopatrzenia,
+Current Stock,Bieżący asortyment,
+PUR-RFQ-.YYYY.-,PUR-RFQ-.RRRR.-,
+For individual supplier,Dla indywidualnego dostawcy,
+Link to Material Requests,Link do żądań materiałów,
+Message for Supplier,Wiadomość dla dostawcy,
+Request for Quotation Item,Przedmiot zapytania ofertowego,
+Required Date,Data wymagana,
+Request for Quotation Supplier,Zapytanie ofertowe do dostawcy,
+Send Email,Wyślij E-mail,
+Quote Status,Status statusu,
+Download PDF,Pobierz PDF,
+Supplier of Goods or Services.,Dostawca towarów lub usług.,
+Name and Type,Nazwa i typ,
+SUP-.YYYY.-,SUP-.RRRR.-,
+Default Bank Account,Domyślne konto bankowe,
+Is Transporter,Dostarcza we własnym zakresie,
+Represents Company,Reprezentuje firmę,
+Supplier Type,Typ dostawcy,
+Allow Purchase Invoice Creation Without Purchase Order,Zezwalaj na tworzenie faktur zakupu bez zamówienia zakupu,
+Allow Purchase Invoice Creation Without Purchase Receipt,Zezwalaj na tworzenie faktur zakupu bez pokwitowania zakupu,
+Warn RFQs,Informuj o złożonych zapytaniach ofertowych,
+Warn POs,Informuj o złożonych zamówieniach,
+Prevent RFQs,Zapobiegaj złożeniu zapytania ofertowego,
+Prevent POs,Zapobiegaj złożeniu zamówienia,
+Billing Currency,Waluta rozliczenia,
+Default Payment Terms Template,Domyślny szablon warunków płatności,
+Block Supplier,Blokuj dostawcę,
+Hold Type,Hold Type,
+Leave blank if the Supplier is blocked indefinitely,"Pozostaw puste, jeśli dostawca jest blokowany na czas nieokreślony",
+Default Payable Accounts,Domyślne konta Rozrachunki z dostawcami,
+Mention if non-standard payable account,"Wspomnij, jeśli nietypowe konto płatne",
+Default Tax Withholding Config,Domyślna konfiguracja podatku u źródła,
+Supplier Details,Szczegóły dostawcy,
+Statutory info and other general information about your Supplier,Informacje prawne na temat dostawcy,
+PUR-SQTN-.YYYY.-,PUR-SQTN-.RRRR.-,
+Supplier Address,Adres dostawcy,
+Link to material requests,Link do żądań materialnych,
+Rounding Adjustment (Company Currency,Korekta zaokrągleń (waluta firmy,
+Auto Repeat Section,Sekcja automatycznego powtarzania,
+Is Subcontracted,Czy zlecony,
+Lead Time in days,Czas oczekiwania w dniach,
+Supplier Score,Ocena Dostawcy,
+Indicator Color,Kolor wskaźnika,
+Evaluation Period,Okres próbny,
+Per Week,Na tydzień,
+Per Month,Na miesiąc,
+Per Year,Na rok,
+Scoring Setup,Konfiguracja punktów,
+Weighting Function,Funkcja ważenia,
+"Scorecard variables can be used, as well as:\n{total_score} (the total score from that period),\n{period_number} (the number of periods to present day)\n","Mogą być stosowane zmienne kartoteki, a także: {total_score} (całkowity wynik z tego okresu), {period_number} (liczba okresów na dzień dzisiejszy)",
+Scoring Standings,Zaplanuj miejsca,
+Criteria Setup,Konfiguracja kryteriów,
+Load All Criteria,Załaduj wszystkie kryteria,
+Scoring Criteria,Kryteria oceny,
+Scorecard Actions,Działania kartoteki,
+Warn for new Request for Quotations,Ostrzegaj przed nowym żądaniem ofert,
+Warn for new Purchase Orders,Ostrzegaj o nowych zamówieniach zakupu,
+Notify Supplier,Powiadom o Dostawcy,
+Notify Employee,Powiadom o pracowniku,
+Supplier Scorecard Criteria,Kryteria oceny dostawcy Dostawcy,
+Criteria Name,Kryteria Nazwa,
+Max Score,Maksymalny wynik,
+Criteria Formula,Wzór Kryterium,
+Criteria Weight,Kryteria Waga,
+Supplier Scorecard Period,Okres kartoteki dostawcy,
+PU-SSP-.YYYY.-,PU-SSP-.YYYY.-,
+Period Score,Wynik okresu,
+Calculations,Obliczenia,
+Criteria,Kryteria,
+Variables,Zmienne,
+Supplier Scorecard Setup,Ustawienia karty wyników dostawcy,
+Supplier Scorecard Scoring Criteria,Kryteria oceny scoringowej dostawcy,
+Score,Wynik,
+Supplier Scorecard Scoring Standing,Dostawca Scorecard Stanowisko,
+Standing Name,Reputacja,
+Purple,Fioletowy,
+Yellow,Żółty,
+Orange,Pomarańczowy,
+Min Grade,Min. wynik,
+Max Grade,Maks. wynik,
+Warn Purchase Orders,Ostrzegaj Zamówienia Zakupu,
+Prevent Purchase Orders,Zapobiegaj zamówieniom zakupu,
+Employee ,Pracownik,
+Supplier Scorecard Scoring Variable,Dostawca Scorecard Zmienna scoringowa,
+Variable Name,Nazwa zmiennej,
+Parameter Name,Nazwa parametru,
+Supplier Scorecard Standing,Dostawca Scorecard Standing,
+Notify Other,Powiadamiaj inne,
+Supplier Scorecard Variable,Zmienną Scorecard dostawcy,
+Call Log,Rejestr połączeń,
+Received By,Otrzymane przez,
+Caller Information,Informacje o dzwoniącym,
+Contact Name,Nazwa kontaktu,
+Lead ,Prowadzić,
+Lead Name,Nazwa Tropu,
+Ringing,Dzwonienie,
+Missed,Nieodebrane,
+Call Duration in seconds,Czas trwania połączenia w sekundach,
+Recording URL,Adres URL nagrywania,
+Communication Medium,Środki komunikacji,
+Communication Medium Type,Typ medium komunikacyjnego,
+Voice,Głos,
+Catch All,Złap wszystkie,
+"If there is no assigned timeslot, then communication will be handled by this group","Jeśli nie ma przypisanej szczeliny czasowej, komunikacja będzie obsługiwana przez tę grupę",
+Timeslots,Szczeliny czasowe,
+Communication Medium Timeslot,Średni czas komunikacji,
+Employee Group,Grupa pracowników,
+Appointment,Spotkanie,
+Scheduled Time,Zaplanowany czas,
+Unverified,Niesprawdzony,
+Customer Details,Dane Klienta,
+Phone Number,Numer telefonu,
+Skype ID,Nazwa Skype,
+Linked Documents,Powiązane dokumenty,
+Appointment With,Spotkanie z,
+Calendar Event,Wydarzenie z kalendarza,
+Appointment Booking Settings,Ustawienia rezerwacji terminu,
+Enable Appointment Scheduling,Włącz harmonogram spotkań,
+Agent Details,Dane agenta,
+Availability Of Slots,Dostępność automatów,
+Number of Concurrent Appointments,Liczba jednoczesnych spotkań,
+Agents,Agenci,
+Appointment Details,Szczegóły terminu,
+Appointment Duration (In Minutes),Czas trwania spotkania (w minutach),
+Notify Via Email,Powiadom przez e-mail,
+Notify customer and agent via email on the day of the appointment.,Powiadom klienta i agenta za pośrednictwem poczty elektronicznej w dniu spotkania.,
+Number of days appointments can be booked in advance,Liczbę dni można umawiać z wyprzedzeniem,
+Success Settings,Ustawienia sukcesu,
+Success Redirect URL,Sukces Przekierowanie URL,
+"Leave blank for home.\nThis is relative to site URL, for example ""about"" will redirect to ""https://yoursitename.com/about""","Pozostaw puste w domu. Jest to względne w stosunku do adresu URL witryny, na przykład „about” przekieruje na „https://yoursitename.com/about”",
+Appointment Booking Slots,Terminy rezerwacji spotkań,
+Day Of Week,Dzień tygodnia,
+From Time ,Od czasu,
+Campaign Email Schedule,Harmonogram e-mailu kampanii,
+Send After (days),Wyślij po (dni),
+Signed,Podpisano,
+Party User,Użytkownik strony,
+Unsigned,Bez podpisu,
+Fulfilment Status,Status realizacji,
+N/A,Nie dotyczy,
+Unfulfilled,Niespełnione,
+Partially Fulfilled,Częściowo zrealizowane,
+Fulfilled,Spełniony,
+Lapsed,Nieaktualne,
+Contract Period,Okres umowy,
+Signee Details,Szczegóły dotyczące Signee,
+Signee,Signee,
+Signed On,Podpisano,
+Contract Details,Szczegóły umowy,
+Contract Template,Szablon umowy,
+Contract Terms,Warunki kontraktu,
+Fulfilment Details,Szczegóły realizacji,
+Requires Fulfilment,Wymaga spełnienia,
+Fulfilment Deadline,Termin realizacji,
+Fulfilment Terms,Warunki realizacji,
+Contract Fulfilment Checklist,Lista kontrolna realizacji kontraktu,
+Requirement,Wymaganie,
+Contract Terms and Conditions,Warunki umowy,
+Fulfilment Terms and Conditions,Spełnienie warunków,
+Contract Template Fulfilment Terms,Warunki realizacji szablonu umowy,
+Email Campaign,Kampania e-mailowa,
+Email Campaign For ,Kampania e-mailowa dla,
+Lead is an Organization,Ołów to organizacja,
+CRM-LEAD-.YYYY.-,CRM-LEAD-.RRRR.-,
+Person Name,Imię i nazwisko osoby,
+Lost Quotation,Przegrana notowań,
+Interested,Jestem zainteresowany,
+Converted,Przekształcono,
+Do Not Contact,Nie Kontaktuj,
+From Customer,Od klienta,
+Campaign Name,Nazwa kampanii,
+Follow Up,Zagryźć,
+Next Contact By,Następny Kontakt Po,
+Next Contact Date,Data Następnego Kontaktu,
+Ends On,Koniec w dniu,
+Address & Contact,Adres i kontakt,
+Mobile No.,Nr tel. Komórkowego,
+Lead Type,Typ Tropu,
+Consultant,Konsultant,
+Market Segment,Segment rynku,
+Industry,Przedsiębiorstwo,
+Request Type,Typ zapytania,
+Product Enquiry,Zapytanie o produkt,
+Request for Information,Prośba o informację,
+Suggestions,Sugestie,
+Blog Subscriber,Subskrybent Bloga,
+LinkedIn Settings,Ustawienia LinkedIn,
+Company ID,identyfikator firmy,
+OAuth Credentials,Poświadczenia OAuth,
+Consumer Key,Klucz klienta,
+Consumer Secret,Sekret konsumenta,
+User Details,Dane użytkownika,
+Person URN,Osoba URN,
+Session Status,Stan sesji,
+Lost Reason Detail,Szczegóły utraconego powodu,
+Opportunity Lost Reason,Możliwość utracona z powodu,
+Potential Sales Deal,Szczegóły potencjalnych sprzedaży,
+CRM-OPP-.YYYY.-,CRM-OPP-.RRRR.-,
+Opportunity From,Szansa od,
+Customer / Lead Name,Nazwa Klienta / Tropu,
+Opportunity Type,Typ szansy,
+Converted By,Przekształcony przez,
+Sales Stage,Etap sprzedaży,
+Lost Reason,Powód straty,
+Expected Closing Date,Oczekiwana data zamknięcia,
+To Discuss,Do omówienia,
+With Items,Z przedmiotami,
+Probability (%),Prawdopodobieństwo (%),
+Contact Info,Dane kontaktowe,
+Customer / Lead Address,Adres Klienta / Tropu,
+Contact Mobile No,Numer komórkowy kontaktu,
+Enter name of campaign if source of enquiry is campaign,Wpisz nazwę przeprowadzanej kampanii jeżeli źródło pytania jest kampanią,
+Opportunity Date,Data szansy,
+Opportunity Item,Przedmiot Szansy,
+Basic Rate,Podstawowy wskaźnik,
+Stage Name,Pseudonim artystyczny,
+Social Media Post,Post w mediach społecznościowych,
+Post Status,Stan publikacji,
+Posted,Wysłano,
+Share On,Podziel się na,
+Twitter,Świergot,
+LinkedIn,LinkedIn,
+Twitter Post Id,Identyfikator posta na Twitterze,
+LinkedIn Post Id,Identyfikator posta na LinkedIn,
+Tweet,Ćwierkać,
+Twitter Settings,Ustawienia Twittera,
+API Secret Key,Tajny klucz API,
+Term Name,Nazwa Term,
+Term Start Date,Termin Data rozpoczęcia,
+Term End Date,Term Data zakończenia,
+Academics User,Studenci,
+Academic Year Name,Nazwa Roku Akademickiego,
+Article,Artykuł,
+LMS User,Użytkownik LMS,
+Assessment Criteria Group,Kryteria oceny grupowej,
+Assessment Group Name,Nazwa grupy Assessment,
+Parent Assessment Group,Rodzic Assesment Group,
+Assessment Name,Nazwa ocena,
+Grading Scale,Skala ocen,
+Examiner,Egzaminator,
+Examiner Name,Nazwa Examiner,
+Supervisor,Kierownik,
+Supervisor Name,Nazwa Supervisor,
+Evaluate,Oceniać,
+Maximum Assessment Score,Maksymalny wynik oceny,
+Assessment Plan Criteria,Kryteria oceny planu,
+Maximum Score,Maksymalna liczba punktów,
+Result,Wynik,
+Total Score,Całkowity wynik,
+Grade,Stopień,
+Assessment Result Detail,Wynik oceny Szczegóły,
+Assessment Result Tool,Wynik oceny Narzędzie,
+Result HTML,wynik HTML,
+Content Activity,Aktywność treści,
+Last Activity ,Ostatnia aktywność,
+Content Question,Pytanie dotyczące treści,
+Question Link,Link do pytania,
+Course Name,Nazwa przedmiotu,
+Topics,Tematy,
+Hero Image,Obraz bohatera,
+Default Grading Scale,Domyślna skala ocen,
+Education Manager,Menedżer edukacji,
+Course Activity,Aktywność na kursie,
+Course Enrollment,Rejestracja kursu,
+Activity Date,Data aktywności,
+Course Assessment Criteria,Kryteria oceny kursu,
+Weightage,Waga/wiek,
+Course Content,Zawartość kursu,
+Quiz,Kartkówka,
+Program Enrollment,Rejestracja w programie,
+Enrollment Date,Data rejestracji,
+Instructor Name,Instruktor Nazwa,
+EDU-CSH-.YYYY.-,EDU-CSH-.RRRR.-,
+Course Scheduling Tool,Oczywiście Narzędzie Scheduling,
+Course Start Date,Data rozpoczęcia kursu,
+To TIme,Do czasu,
+Course End Date,Data zakończenia kursu,
+Course Topic,Temat kursu,
+Topic,Temat,
+Topic Name,Nazwa tematu,
+Education Settings,Ustawienia edukacji,
+Current Academic Year,Obecny Rok Akademicki,
+Current Academic Term,Obecny termin akademicki,
+Attendance Freeze Date,Data zamrożenia obecności,
+Validate Batch for Students in Student Group,Sprawdź partię dla studentów w grupie studentów,
+"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Dla grupy studentów opartej na partiach, partia ucznia zostanie zatwierdzona dla każdego ucznia z wpisu do programu.",
+Validate Enrolled Course for Students in Student Group,Zatwierdzić zapisany kurs dla studentów w grupie studentów,
+"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",Dla Grupy Studenckiej na Kursie kurs zostanie sprawdzony dla każdego Uczestnika z zapisanych kursów w ramach Rejestracji Programu.,
+Make Academic Term Mandatory,Uczyń okres akademicki obowiązkowym,
+"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Jeśli opcja jest włączona, pole Akademickie oznaczenie będzie obowiązkowe w narzędziu rejestrowania programu.",
+Skip User creation for new Student,Pomiń tworzenie użytkownika dla nowego Studenta,
+"By default, a new User is created for every new Student. If enabled, no new User will be created when a new Student is created.","Domyślnie dla każdego nowego Studenta tworzony jest nowy Użytkownik. Jeśli ta opcja jest włączona, żaden nowy Użytkownik nie zostanie utworzony po utworzeniu nowego Studenta.",
+Instructor Records to be created by,"Rekord instruktorski, który zostanie utworzony przez",
+Employee Number,Numer pracownika,
+Fee Category,opłata Kategoria,
+Fee Component,opłata Komponent,
+Fees Category,Opłaty Kategoria,
+Fee Schedule,Harmonogram opłat,
+Fee Structure,Struktura opłat,
+EDU-FSH-.YYYY.-,EDU-FSH-.YYYY.-,
+Fee Creation Status,Status tworzenia licencji,
+In Process,W trakcie,
+Send Payment Request Email,Wyślij e-mail z zapytaniem o płatność,
+Student Category,Student Kategoria,
+Fee Breakup for each student,Podział wynagrodzenia dla każdego ucznia,
+Total Amount per Student,Łączna kwota na jednego studenta,
+Institution,Instytucja,
+Fee Schedule Program,Program planu opłat,
+Student Batch,Batch Student,
+Total Students,Wszystkich studentów,
+Fee Schedule Student Group,Plan zajęć grupy studentów,
+EDU-FST-.YYYY.-,EDU-FST-.YYYY.-,
+EDU-FEE-.YYYY.-,EDU-FEE-.YYYY.-,
+Include Payment,Dołącz płatności,
+Send Payment Request,Wyślij żądanie płatności,
+Student Details,Szczegóły Uczniów,
+Student Email,E-mail dla studentów,
+Grading Scale Name,Skala ocen Nazwa,
+Grading Scale Intervals,Odstępy Skala ocen,
+Intervals,przedziały,
+Grading Scale Interval,Skala ocen Interval,
+Grade Code,Kod klasy,
+Threshold,Próg,
+Grade Description,Stopień Opis,
+Guardian,Opiekun,
+Guardian Name,Nazwa Stróża,
+Alternate Number,Alternatywny numer,
+Occupation,Zawód,
+Work Address,Adres miejsca pracy,
+Guardian Of ,Strażnik,
+Students,studenci,
+Guardian Interests,opiekun Zainteresowania,
+Guardian Interest,Strażnik Odsetki,
+Interest,Zainteresowanie,
+Guardian Student,opiekun studenta,
+EDU-INS-.YYYY.-,EDU-INS-.YYYY.-,
+Instructor Log,Dziennik instruktora,
+Other details,Pozostałe szczegóły,
+Option,Opcja,
+Is Correct,Jest poprawne,
+Program Name,Nazwa programu,
+Program Abbreviation,Skrót programu,
+Courses,Pola,
+Is Published,Jest opublikowany,
+Allow Self Enroll,Zezwalaj na samodzielne zapisywanie się,
+Is Featured,Jest zawarty,
+Intro Video,Intro Video,
+Program Course,Program kursu,
+School House,school House,
+Boarding Student,Student Wyżywienia,
+Check this if the Student is residing at the Institute's Hostel.,"Sprawdź, czy Student mieszka w Hostelu Instytutu.",
+Walking,Pieszy,
+Institute's Bus,Autobus Instytutu,
+Public Transport,Transport publiczny,
+Self-Driving Vehicle,Samochód osobowy,
+Pick/Drop by Guardian,Pick / Drop przez Guardian,
+Enrolled courses,Zaplanowane kursy,
+Program Enrollment Course,Kurs rekrutacji,
+Program Enrollment Fee,Program Rejestracji Opłata,
+Program Enrollment Tool,Rejestracja w programie Narzędzie,
+Get Students From,Uzyskaj studentów z,
+Student Applicant,Student Wnioskodawca,
+Get Students,Uzyskaj Studentów,
+Enrollment Details,Szczegóły rejestracji,
+New Program,Nowy program,
+New Student Batch,Nowa partia studencka,
+Enroll Students,zapisać studentów,
+New Academic Year,Nowy rok akademicki,
+New Academic Term,Nowy okres akademicki,
+Program Enrollment Tool Student,Rejestracja w programie Narzędzie Student,
+Student Batch Name,Student Batch Nazwa,
+Program Fee,Opłata Program,
+Question,Pytanie,
+Single Correct Answer,Pojedyncza poprawna odpowiedź,
+Multiple Correct Answer,Wielokrotna poprawna odpowiedź,
+Quiz Configuration,Konfiguracja quizu,
+Passing Score,Wynik pozytywny,
+Score out of 100,Wynik na 100,
+Max Attempts,Max Próby,
+Enter 0 to waive limit,"Wprowadź 0, aby zrezygnować z limitu",
+Grading Basis,Podstawa klasyfikacji,
+Latest Highest Score,Najnowszy najwyższy wynik,
+Latest Attempt,Ostatnia próba,
+Quiz Activity,Aktywność Quiz,
+Enrollment,Rekrutacja,
+Pass,Przechodzić,
+Quiz Question,Pytanie do quizu,
+Quiz Result,Wynik testu,
+Selected Option,Wybrana opcja,
+Correct,Poprawny,
+Wrong,Źle,
+Room Name,Nazwa pokoju,
+Room Number,Numer pokoju,
+Seating Capacity,Liczba miejsc,
+House Name,Nazwa domu,
+EDU-STU-.YYYY.-,EDU-STU-.RRRR.-,
+Student Mobile Number,Student Mobile Number,
+Joining Date,Data Dołączenia,
+Blood Group,Grupa Krwi,
+A+,A+,
+A-,A-,
+B+,B +,
+B-,B-,
+O+,O +,
+O-,O-,
+AB+,AB +,
+AB-,AB-,
+Nationality,Narodowość,
+Home Address,Adres domowy,
+Guardian Details,Szczegóły Stróża,
+Guardians,Strażnicy,
+Sibling Details,rodzeństwo Szczegóły,
+Siblings,Rodzeństwo,
+Exit,Wyjście,
+Date of Leaving,Data Pozostawiając,
+Leaving Certificate Number,Pozostawiając numer certyfikatu,
+Reason For Leaving,Powód odejścia,
+Student Admission,Wstęp Student,
+Admission Start Date,Wstęp Data rozpoczęcia,
+Admission End Date,Wstęp Data zakończenia,
+Publish on website,Opublikuj na stronie internetowej,
+Eligibility and Details,Kwalifikowalność i szczegóły,
+Student Admission Program,Studencki program przyjęć,
+Minimum Age,Minimalny wiek,
+Maximum Age,Maksymalny wiek,
+Application Fee,Opłata za zgłoszenie,
+Naming Series (for Student Applicant),Naming Series (dla Studenta Wnioskodawcy),
+LMS Only,Tylko LMS,
+EDU-APP-.YYYY.-,EDU-APP-.RRRR.-,
+Application Status,Status aplikacji,
+Application Date,Data złożenia wniosku,
+Student Attendance Tool,Obecność Student Narzędzie,
+Group Based On,Grupa oparta na,
+Students HTML,studenci HTML,
+Group Based on,Grupa oparta na,
+Student Group Name,Nazwa grupy studentów,
+Max Strength,Maksymalna siła,
+Set 0 for no limit,Ustaw 0 oznacza brak limitu,
+Instructors,instruktorzy,
+Student Group Creation Tool,Narzędzie tworzenia grupy studenta,
+Leave blank if you make students groups per year,"Zostaw puste, jeśli uczysz grupy studentów rocznie",
+Get Courses,Uzyskaj kursy,
+Separate course based Group for every Batch,Oddzielna grupa kursów dla każdej partii,
+Leave unchecked if you don't want to consider batch while making course based groups. ,"Opuść zaznaczenie, jeśli nie chcesz rozważyć partii przy jednoczesnym tworzeniu grup kursów.",
+Student Group Creation Tool Course,Kurs grupy studentów Stworzenie narzędzia,
+Course Code,Kod kursu,
+Student Group Instructor,Instruktor grupy studentów,
+Student Group Student,Student Grupa Student,
+Group Roll Number,Numer grupy,
+Student Guardian,Student Stróża,
+Relation,Relacja,
+Mother,Mama,
+Father,Ojciec,
+Student Language,Student Język,
+Student Leave Application,Student Application Leave,
+Mark as Present,Oznacz jako Present,
+Student Log,Dziennik studenta,
+Academic,Akademicki,
+Achievement,Osiągnięcie,
+Student Report Generation Tool,Narzędzie do generowania raportów uczniów,
+Include All Assessment Group,Uwzględnij całą grupę oceny,
+Show Marks,Pokaż znaczniki,
+Add letterhead,Dodaj papier firmowy,
+Print Section,Sekcja drukowania,
+Total Parents Teacher Meeting,Spotkanie nauczycieli wszystkich rodziców,
+Attended by Parents,Uczestniczyli w nim rodzice,
+Assessment Terms,Warunki oceny,
+Student Sibling,Student Rodzeństwo,
+Studying in Same Institute,Studia w sam instytut,
+NO,NIE,
+YES,Tak,
+Student Siblings,Rodzeństwo studenckie,
+Topic Content,Treść tematu,
+Amazon MWS Settings,Ustawienia Amazon MWS,
+ERPNext Integrations,Integracje ERPNext,
+Enable Amazon,Włącz Amazon,
+MWS Credentials,Poświadczenia MWS,
+Seller ID,ID sprzedawcy,
+AWS Access Key ID,AWS Access Key ID,
+MWS Auth Token,MWh Auth Token,
+Market Place ID,Identyfikator rynku,
+AE,AE,
+AU,AU,
+BR,BR,
+CA,CA,
+CN,CN,
+DE,DE,
+ES,ES,
+FR,FR,
+IN,W,
+JP,JP,
+IT,TO,
+MX,MX,
+UK,Wielka Brytania,
+US,NAS,
+Customer Type,typ klienta,
+Market Place Account Group,Grupa konta rynkowego,
+After Date,Po dacie,
+Amazon will synch data updated after this date,Amazon zsynchronizuje dane zaktualizowane po tej dacie,
+Sync Taxes and Charges,Synchronizuj podatki i opłaty,
+Get financial breakup of Taxes and charges data by Amazon ,Uzyskaj rozpad finansowy danych podatkowych i obciążeń przez Amazon,
+Sync Products,Synchronizuj produkty,
+Always sync your products from Amazon MWS before synching the Orders details,Zawsze synchronizuj swoje produkty z Amazon MWS przed zsynchronizowaniem szczegółów Zamówienia,
+Sync Orders,Synchronizuj zamówienia,
+Click this button to pull your Sales Order data from Amazon MWS.,"Kliknij ten przycisk, aby pobrać dane zamówienia sprzedaży z Amazon MWS.",
+Enable Scheduled Sync,Włącz zaplanowaną synchronizację,
+Check this to enable a scheduled Daily synchronization routine via scheduler,"Zaznacz to ustawienie, aby włączyć zaplanowaną codzienną procedurę synchronizacji za pośrednictwem programu planującego",
+Max Retry Limit,Maksymalny limit ponownych prób,
+Exotel Settings,Ustawienia Exotel,
+Account SID,SID konta,
+API Token,Token API,
+GoCardless Mandate,Upoważnienie GoCardless,
+Mandate,Mandat,
+GoCardless Customer,Klient bez karty,
+GoCardless Settings,Ustawienia bez karty,
+Webhooks Secret,Sekret Webhooks,
+Plaid Settings,Ustawienia Plaid,
+Synchronize all accounts every hour,Synchronizuj wszystkie konta co godzinę,
+Plaid Client ID,Identyfikator klienta w kratkę,
+Plaid Secret,Plaid Secret,
+Plaid Environment,Plaid Environment,
+sandbox,piaskownica,
+development,rozwój,
+production,produkcja,
+QuickBooks Migrator,QuickBooks Migrator,
+Application Settings,Ustawienia aplikacji,
+Token Endpoint,Token Endpoint,
+Scope,Zakres,
+Authorization Settings,Ustawienia autoryzacji,
+Authorization Endpoint,Punkt końcowy autoryzacji,
+Authorization URL,Adres URL autoryzacji,
+Quickbooks Company ID,Quickbooks Identyfikator firmy,
+Company Settings,Ustawienia firmy,
+Default Shipping Account,Domyślne konto wysyłkowe,
+Default Warehouse,Domyślny magazyn,
+Default Cost Center,Domyślne Centrum Kosztów,
+Undeposited Funds Account,Rachunek nierozliczonych funduszy,
+Shopify Log,Shopify Log,
+Request Data,Żądaj danych,
+Shopify Settings,Zmień ustawienia,
+status html,status html,
+Enable Shopify,Włącz Shopify,
+App Type,Typ aplikacji,
+Last Sync Datetime,Ostatnia synchronizacja Datetime,
+Shop URL,URL sklepu,
+eg: frappe.myshopify.com,np .: frappe.myshopify.com,
+Shared secret,Wspólny sekret,
+Webhooks Details,Szczegóły Webhooks,
+Webhooks,Webhooks,
+Customer Settings,Ustawienia klienta,
+Default Customer,Domyślny klient,
+Customer Group will set to selected group while syncing customers from Shopify,Grupa klientów ustawi wybraną grupę podczas synchronizowania klientów z Shopify,
+For Company,Dla firmy,
+Cash Account will used for Sales Invoice creation,Konto gotówkowe zostanie użyte do utworzenia faktury sprzedaży,
+Update Price from Shopify To ERPNext Price List,Zaktualizuj cenę z Shopify To ERPNext Price List,
+Default Warehouse to to create Sales Order and Delivery Note,"Domyślny magazyn, aby utworzyć zamówienie sprzedaży i dostawę",
+Sales Order Series,Seria zamówień sprzedaży,
+Import Delivery Notes from Shopify on Shipment,Importuj notatki dostawy z Shopify w przesyłce,
+Delivery Note Series,Seria notatek dostawy,
+Import Sales Invoice from Shopify if Payment is marked,"Importuj fakturę sprzedaży z Shopify, jeśli płatność została zaznaczona",
+Sales Invoice Series,Seria faktur sprzedaży,
+Shopify Tax Account,Shopify Tax Account,
+Shopify Tax/Shipping Title,Kupuj podatek / tytuł dostawy,
+ERPNext Account,ERPNext Konto,
+Shopify Webhook Detail,Szczegółowe informacje o Shophook,
+Webhook ID,Identyfikator Webhooka,
+Tally Migration,Tally Migration,
+Master Data,Dane podstawowe,
+"Data exported from Tally that consists of the Chart of Accounts, Customers, Suppliers, Addresses, Items and UOMs","Dane wyeksportowane z Tally, które obejmują plan kont, klientów, dostawców, adresy, towary i jednostki miary",
+Is Master Data Processed,Czy przetwarzane są dane podstawowe,
+Is Master Data Imported,Czy importowane są dane podstawowe,
+Tally Creditors Account,Tally Credit Accounts,
+Creditors Account set in Tally,Konto wierzycieli ustawione w Tally,
+Tally Debtors Account,Rachunek Dłużników Tally,
+Debtors Account set in Tally,Konto dłużników ustawione w Tally,
+Tally Company,Firma Tally,
+Company Name as per Imported Tally Data,Nazwa firmy zgodnie z zaimportowanymi danymi Tally,
+Default UOM,Domyślna jednostka miary,
+UOM in case unspecified in imported data,JM w przypadku nieokreślonego w importowanych danych,
+ERPNext Company,ERPNext Company,
+Your Company set in ERPNext,Twoja firma ustawiona w ERPNext,
+Processed Files,Przetworzone pliki,
+Parties,Strony,
+UOMs,Jednostki miary,
+Vouchers,Kupony,
+Round Off Account,Konto kwot zaokrągleń,
+Day Book Data,Dane książki dziennej,
+Day Book Data exported from Tally that consists of all historic transactions,"Dane księgi dziennej wyeksportowane z Tally, które zawierają wszystkie historyczne transakcje",
+Is Day Book Data Processed,Czy przetwarzane są dane dzienników,
+Is Day Book Data Imported,Importowane są dane dzienników,
+Woocommerce Settings,Ustawienia Woocommerce,
+Enable Sync,Włącz synchronizację,
+Woocommerce Server URL,URL serwera Woocommerce,
+Secret,Sekret,
+API consumer key,Klucz konsumenta API,
+API consumer secret,Tajny klucz klienta API,
+Tax Account,Konto podatkowe,
+Freight and Forwarding Account,Konto spedycyjne i spedycyjne,
+Creation User,Użytkownik tworzenia,
+"The user that will be used to create Customers, Items and Sales Orders. This user should have the relevant permissions.","Użytkownik, który będzie używany do tworzenia klientów, towarów i zleceń sprzedaży. Ten użytkownik powinien mieć odpowiednie uprawnienia.",
+"This warehouse will be used to create Sales Orders. The fallback warehouse is ""Stores"".",Ten magazyn będzie używany do tworzenia zamówień sprzedaży. Magazyn zapasowy to „Sklepy”.,
+"The fallback series is ""SO-WOO-"".",Seria awaryjna to „SO-WOO-”.,
+This company will be used to create Sales Orders.,Ta firma będzie używana do tworzenia zamówień sprzedaży.,
+Delivery After (Days),Dostawa po (dni),
+This is the default offset (days) for the Delivery Date in Sales Orders. The fallback offset is 7 days from the order placement date.,Jest to domyślne przesunięcie (dni) dla daty dostawy w zamówieniach sprzedaży. Przesunięcie awaryjne wynosi 7 dni od daty złożenia zamówienia.,
+"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".",Jest to domyślna jednostka miary używana dla elementów i zamówień sprzedaży. Rezerwowym UOM jest „Nos”.,
+Endpoints,Punkty końcowe,
+Endpoint,Punkt końcowy,
+Antibiotic Name,Nazwa antybiotyku,
+Healthcare Administrator,Administrator Ochrony Zdrowia,
+Laboratory User,Użytkownik Laboratorium,
+Is Inpatient,Jest hospitalizowany,
+Default Duration (In Minutes),Domyślny czas trwania (w minutach),
+Body Part,Część ciała,
+Body Part Link,Link do części ciała,
+HLC-CPR-.YYYY.-,HLC-CPR-.RRRR.-,
+Procedure Template,Szablon procedury,
+Procedure Prescription,Procedura Recepta,
+Service Unit,Jednostka serwisowa,
+Consumables,Materiały eksploatacyjne,
+Consume Stock,Zużyj zapasy,
+Invoice Consumables Separately,Fakturuj oddzielnie materiały eksploatacyjne,
+Consumption Invoiced,Zużycie fakturowane,
+Consumable Total Amount,Łączna ilość materiałów eksploatacyjnych,
+Consumption Details,Szczegóły zużycia,
+Nursing User,Pielęgniarka,
+Clinical Procedure Item,Procedura postępowania klinicznego,
+Invoice Separately as Consumables,Faktura oddzielnie jako materiał eksploatacyjny,
+Transfer Qty,Przenieś ilość,
+Actual Qty (at source/target),Rzeczywista Ilość (u źródła/celu),
+Is Billable,Jest rozliczalny,
+Allow Stock Consumption,Zezwalaj na zużycie zapasów,
+Sample UOM,Przykładowa jednostka miary,
+Collection Details,Szczegóły kolekcji,
+Change In Item,Zmiana w pozycji,
+Codification Table,Tabela kodyfikacji,
+Complaints,Uskarżanie się,
+Dosage Strength,Siła dawkowania,
+Strength,Wytrzymałość,
+Drug Prescription,Na receptę,
+Drug Name / Description,Nazwa / opis leku,
+Dosage,Dawkowanie,
+Dosage by Time Interval,Dawkowanie według przedziału czasu,
+Interval,Interwał,
+Interval UOM,Interwał UOM,
+Hour,Godzina,
+Update Schedule,Zaktualizuj harmonogram,
+Exercise,Ćwiczenie,
+Difficulty Level,Poziom trudności,
+Counts Target,Liczy cel,
+Counts Completed,Liczenie zakończone,
+Assistance Level,Poziom pomocy,
+Active Assist,Aktywna pomoc,
+Exercise Name,Nazwa ćwiczenia,
+Body Parts,Części ciała,
+Exercise Instructions,Instrukcje do ćwiczeń,
+Exercise Video,Ćwiczenia wideo,
+Exercise Steps,Kroki ćwiczeń,
+Steps,Kroki,
+Steps Table,Tabela kroków,
+Exercise Type Step,Krok typu ćwiczenia,
+Max number of visit,Maksymalna liczba wizyt,
+Visited yet,Jeszcze odwiedziłem,
+Reference Appointments,Spotkania referencyjne,
+Valid till,Obowiązuje do,
+Fee Validity Reference,Odniesienie do ważności opłat,
+Basic Details,Podstawowe szczegóły,
+HLC-PRAC-.YYYY.-,HLC-PRAC-.YYYY.-,
+Mobile,mobilny,
+Phone (R),Telefon (R),
+Phone (Office),Telefon (Biuro),
+Employee and User Details,Dane pracownika i użytkownika,
+Hospital,Szpital,
+Appointments,Terminy,
+Practitioner Schedules,Harmonogramy praktyków,
+Charges,Opłaty,
+Out Patient Consulting Charge,Opłata za konsultacje z pacjentem zewnętrznym,
+Default Currency,Domyślna waluta,
+Healthcare Schedule Time Slot,Schemat czasu opieki zdrowotnej,
+Parent Service Unit,Jednostka usług dla rodziców,
+Service Unit Type,Rodzaj jednostki usługi,
+Allow Appointments,Zezwalaj na spotkania,
+Allow Overlap,Zezwalaj na Nakładanie,
+Inpatient Occupancy,Zajęcia stacjonarne,
+Occupancy Status,Status obłożenia,
+Vacant,Pusty,
+Occupied,Zajęty,
+Item Details,Szczegóły produktu,
+UOM Conversion in Hours,Konwersja UOM w godzinach,
+Rate / UOM,Rate / UOM,
+Change in Item,Zmień pozycję,
+Out Patient Settings,Out Ustawienia pacjenta,
+Patient Name By,Nazwisko pacjenta,
+Patient Name,Imię pacjenta,
+Link Customer to Patient,Połącz klienta z pacjentem,
+"If checked, a customer will be created, mapped to Patient.\nPatient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.","Jeśli zostanie zaznaczone, zostanie utworzony klient, który będzie mapowany na pacjenta. Dla tego klienta powstanie faktury pacjenta. Można również wybrać istniejącego klienta podczas tworzenia pacjenta.",
+Default Medical Code Standard,Domyślny standard kodu medycznego,
+Collect Fee for Patient Registration,Zbierz opłatę za rejestrację pacjenta,
+Checking this will create new Patients with a Disabled status by default and will only be enabled after invoicing the Registration Fee.,Zaznaczenie tej opcji spowoduje utworzenie nowych pacjentów ze statusem Wyłączony domyślnie i będzie włączone dopiero po zafakturowaniu Opłaty rejestracyjnej.,
+Registration Fee,Opłata za rejestrację,
+Automate Appointment Invoicing,Zautomatyzuj fakturowanie spotkań,
+Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Zarządzaj fakturą Powołania automatycznie przesyłaj i anuluj spotkanie z pacjentem,
+Enable Free Follow-ups,Włącz bezpłatne obserwacje,
+Number of Patient Encounters in Valid Days,Liczba spotkań pacjentów w ważne dni,
+The number of free follow ups (Patient Encounters in valid days) allowed,Dozwolona liczba bezpłatnych obserwacji (spotkań pacjentów w ważnych dniach),
+Valid Number of Days,Ważna liczba dni,
+Time period (Valid number of days) for free consultations,Okres (ważna liczba dni) na bezpłatne konsultacje,
+Default Healthcare Service Items,Domyślne pozycje usług opieki zdrowotnej,
+"You can configure default Items for billing consultation charges, procedure consumption items and inpatient visits","Można skonfigurować pozycje domyślne w celu rozliczenia opłat za konsultacje, pozycji dotyczących zużycia procedur i wizyt szpitalnych",
+Clinical Procedure Consumable Item,Procedura kliniczna Materiały eksploatacyjne,
+Default Accounts,Konta domyślne,
+Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,"Konta z domyślnymi dochodami, które mają być używane, jeśli nie są ustawione w Healthcare Practitioner, aby zarezerwować opłaty za spotkanie.",
+Default receivable accounts to be used to book Appointment charges.,"Domyślne konta należności, które mają być używane do księgowania opłat za spotkanie.",
+Out Patient SMS Alerts,Wypisuj alerty SMS dla pacjentów,
+Patient Registration,Rejestracja pacjenta,
+Registration Message,Wiadomość rejestracyjna,
+Confirmation Message,Wiadomość potwierdzająca,
+Avoid Confirmation,Unikaj Potwierdzenia,
+Do not confirm if appointment is created for the same day,"Nie potwierdzaj, czy spotkanie zostanie utworzone na ten sam dzień",
+Appointment Reminder,Przypomnienie o spotkaniu,
+Reminder Message,Komunikat Przypomnienia,
+Remind Before,Przypomnij wcześniej,
+Laboratory Settings,Ustawienia laboratoryjne,
+Create Lab Test(s) on Sales Invoice Submission,Utwórz testy laboratoryjne podczas przesyłania faktur sprzedaży,
+Checking this will create Lab Test(s) specified in the Sales Invoice on submission.,Zaznaczenie tego spowoduje utworzenie testów laboratoryjnych określonych na fakturze sprzedaży podczas przesyłania.,
+Create Sample Collection document for Lab Test,Utwórz dokument pobierania próbek do testu laboratoryjnego,
+Checking this will create a Sample Collection document  every time you create a Lab Test,"Zaznaczenie tego spowoduje utworzenie dokumentu pobierania próbek za każdym razem, gdy utworzysz test laboratoryjny",
+Employee name and designation in print,Nazwisko pracownika i oznaczenie w druku,
+Check this if you want the Name and Designation of the Employee associated with the User who submits the document to be printed in the Lab Test Report.,"Zaznacz tę opcję, jeśli chcesz, aby nazwa i oznaczenie pracownika skojarzone z użytkownikiem przesyłającym dokument zostały wydrukowane w raporcie z testu laboratoryjnego.",
+Do not print or email Lab Tests without Approval,Nie drukuj ani nie wysyłaj e-mailem testów laboratoryjnych bez zgody,
+Checking this will restrict printing and emailing of Lab Test documents unless they have the status as Approved.,"Zaznaczenie tego ograniczy drukowanie i wysyłanie pocztą elektroniczną dokumentów testów laboratoryjnych, chyba że mają one status Zatwierdzone.",
+Custom Signature in Print,Podpis niestandardowy w druku,
+Laboratory SMS Alerts,Laboratorium SMS Alerts,
+Result Printed Message,Wynik wydrukowany komunikat,
+Result Emailed Message,Wiadomość e-mail z wynikami,
+Check In,Zameldować się,
+Check Out,Sprawdzić,
+HLC-INP-.YYYY.-,HLC-INP-.YYYY.-,
+A Positive,Pozytywny,
+A Negative,Negatywny,
+AB Positive,AB Pozytywne,
+AB Negative,AB Negatywne,
+B Positive,B dodatni,
+B Negative,B Negatywne,
+O Positive,O pozytywne,
+O Negative,O negatywne,
+Date of birth,Data urodzenia,
+Admission Scheduled,Wstęp Zaplanowany,
+Discharge Scheduled,Rozładowanie Zaplanowane,
+Discharged,Rozładowany,
+Admission Schedule Date,Harmonogram przyjęcia,
+Admitted Datetime,Przyjęto Datetime,
+Expected Discharge,Oczekiwany zrzut,
+Discharge Date,Data rozładowania,
+Lab Prescription,Lekarz na receptę,
+Lab Test Name,Nazwa testu laboratoryjnego,
+Test Created,Utworzono test,
+Submitted Date,Zaakceptowana Data,
+Approved Date,Zatwierdzona data,
+Sample ID,Identyfikator wzorcowy,
+Lab Technician,Technik laboratoryjny,
+Report Preference,Preferencje raportu,
+Test Name,Nazwa testu,
+Test Template,Szablon testu,
+Test Group,Grupa testowa,
+Custom Result,Wynik niestandardowy,
+LabTest Approver,Przybliżenie LabTest,
+Add Test,Dodaj test,
+Normal Range,Normalny zakres,
+Result Format,Format wyników,
+Single,Pojedynczy,
+Compound,Złożony,
+Descriptive,Opisowy,
+Grouped,Zgrupowane,
+No Result,Brak wyników,
+This value is updated in the Default Sales Price List.,Ta wartość jest aktualizowana w Domyślnym Cenniku Sprzedaży.,
+Lab Routine,Lab Rutyna,
+Result Value,Wartość wyniku,
+Require Result Value,Wymagaj wartości,
+Normal Test Template,Normalny szablon testu,
+Patient Demographics,Dane demograficzne pacjenta,
+HLC-PAT-.YYYY.-,HLC-PAT-.YYYY.-,
+Middle Name (optional),Drugie imię (opcjonalnie),
+Inpatient Status,Status stacjonarny,
+"If ""Link Customer to Patient"" is checked in Healthcare Settings and an existing Customer is not selected then, a Customer will be created for this Patient for recording transactions in Accounts module.","Jeśli w Ustawieniach opieki zdrowotnej zaznaczono opcję „Połącz klienta z pacjentem”, a istniejący klient nie zostanie wybrany, zostanie utworzony klient dla tego pacjenta w celu rejestrowania transakcji w module kont.",
+Personal and Social History,Historia osobista i społeczna,
+Marital Status,Stan cywilny,
+Married,Żonaty / Zamężna,
+Divorced,Rozwiedziony,
+Widow,Wdowa,
+Patient Relation,Relacja pacjenta,
+"Allergies, Medical and Surgical History","Alergie, historia medyczna i chirurgiczna",
+Allergies,Alergie,
+Medication,Lek,
+Medical History,Historia medyczna,
+Surgical History,Historia chirurgiczna,
+Risk Factors,Czynniki ryzyka,
+Occupational Hazards and Environmental Factors,Zagrożenia zawodowe i czynniki środowiskowe,
+Other Risk Factors,Inne czynniki ryzyka,
+Patient Details,Szczegóły pacjenta,
+Additional information regarding the patient,Dodatkowe informacje dotyczące pacjenta,
+HLC-APP-.YYYY.-,HLC-APP-.YYYY.-,
+Patient Age,Wiek pacjenta,
+Get Prescribed Clinical Procedures,Uzyskaj przepisane procedury kliniczne,
+Therapy,Terapia,
+Get Prescribed Therapies,Uzyskaj przepisane terapie,
+Appointment Datetime,Data spotkania,
+Duration (In Minutes),Czas trwania (w minutach),
+Reference Sales Invoice,Referencyjna faktura sprzedaży,
+More Info,Więcej informacji,
+Referring Practitioner,Polecający praktykujący,
+Reminded,Przypomnij,
+HLC-PA-.YYYY.-,HLC-PA-.YYYY.-,
+Assessment Template,Szablon oceny,
+Assessment Datetime,Czas oceny,
+Assessment Description,Opis oceny,
+Assessment Sheet,Arkusz oceny,
+Total Score Obtained,Całkowity wynik uzyskany,
+Scale Min,Skala min,
+Scale Max,Skala Max,
+Patient Assessment Detail,Szczegóły oceny pacjenta,
+Assessment Parameter,Parametr oceny,
+Patient Assessment Parameter,Parametr oceny pacjenta,
+Patient Assessment Sheet,Arkusz oceny pacjenta,
+Patient Assessment Template,Szablon oceny pacjenta,
+Assessment Parameters,Parametry oceny,
+Parameters,Parametry,
+Assessment Scale,Skala oceny,
+Scale Minimum,Minimalna skala,
+Scale Maximum,Skala maksymalna,
+HLC-ENC-.YYYY.-,HLC-ENC-.YYYY.-,
+Encounter Date,Data spotkania,
+Encounter Time,Czas spotkania,
+Encounter Impression,Encounter Impression,
+Symptoms,Objawy,
+In print,W druku,
+Medical Coding,Kodowanie medyczne,
+Procedures,Procedury,
+Therapies,Terapie,
+Review Details,Szczegóły oceny,
+Patient Encounter Diagnosis,Diagnoza spotkania pacjenta,
+Patient Encounter Symptom,Objaw spotkania pacjenta,
+HLC-PMR-.YYYY.-,HLC-PMR-.YYYY.-,
+Attach Medical Record,Dołącz dokumentację medyczną,
+Reference DocType,Odniesienie do DocType,
+Spouse,Małżonka,
+Family,Rodzina,
+Schedule Details,Szczegóły harmonogramu,
+Schedule Name,Nazwa harmonogramu,
+Time Slots,Szczeliny czasowe,
+Practitioner Service Unit Schedule,Harmonogram jednostki służby zdrowia,
+Procedure Name,Nazwa procedury,
+Appointment Booked,Spotkanie zarezerwowane,
+Procedure Created,Procedura Utworzono,
+HLC-SC-.YYYY.-,HLC-SC-.RRRR.-,
+Collected By,Zbierane przez,
+Particulars,Szczegóły,
+Result Component,Komponent wyników,
+HLC-THP-.YYYY.-,HLC-THP-.YYYY.-,
+Therapy Plan Details,Szczegóły planu terapii,
+Total Sessions,Całkowita liczba sesji,
+Total Sessions Completed,Całkowita liczba ukończonych sesji,
+Therapy Plan Detail,Szczegóły planu terapii,
+No of Sessions,Liczba sesji,
+Sessions Completed,Sesje zakończone,
+Tele,Tele,
+Exercises,Ćwiczenia,
+Therapy For,Terapia dla,
+Add Exercises,Dodaj ćwiczenia,
+Body Temperature,Temperatura ciała,
+Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Obecność gorączki (temp.&gt; 38,5 ° C / 101,3 ° F lub trwała temperatura&gt; 38 ° C / 100,4 ° F)",
+Heart Rate / Pulse,Częstość tętna / impuls,
+Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Częstość tętna wynosi od 50 do 80 uderzeń na minutę.,
+Respiratory rate,Oddechowy,
+Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normalny zakres referencyjny dla dorosłych wynosi 16-20 oddech / minutę (RCP 2012),
+Tongue,Język,
+Coated,Pokryty,
+Very Coated,Bardzo powlekane,
+Normal,Normalna,
+Furry,Futrzany,
+Cuts,Cięcia,
+Abdomen,Brzuch,
+Bloated,Nadęty,
+Fluid,Płyn,
+Constipated,Mający zaparcie,
+Reflexes,Odruchy,
+Hyper,Hyper,
+Very Hyper,Bardzo Hyper,
+One Sided,Jednostronny,
+Blood Pressure (systolic),Ciśnienie krwi (skurczowe),
+Blood Pressure (diastolic),Ciśnienie krwi (rozkurczowe),
+Blood Pressure,Ciśnienie krwi,
+"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Normalne spoczynkowe ciśnienie krwi u dorosłych wynosi około 120 mmHg skurczowe, a rozkurczowe 80 mmHg, skrócone &quot;120/80 mmHg&quot;",
+Nutrition Values,Wartości odżywcze,
+Height (In Meter),Wysokość (w metrze),
+Weight (In Kilogram),Waga (w kilogramach),
+BMI,BMI,
+Hotel Room,Pokój hotelowy,
+Hotel Room Type,Rodzaj pokoju hotelowego,
+Capacity,Pojemność,
+Extra Bed Capacity,Wydajność dodatkowego łóżka,
+Hotel Manager,Kierownik hotelu,
+Hotel Room Amenity,Udogodnienia w pokoju hotelowym,
+Billable,Rozliczalny,
+Hotel Room Package,Pakiet hotelowy,
+Amenities,Udogodnienia,
+Hotel Room Pricing,Ceny pokoi w hotelu,
+Hotel Room Pricing Item,Cennik pokoi hotelowych,
+Hotel Room Pricing Package,Pakiet cen pokoi hotelowych,
+Hotel Room Reservation,Rezerwacja pokoju hotelowego,
+Guest Name,Imię gościa,
+Late Checkin,Późne zameldowanie,
+Booked,Zarezerwowane,
+Hotel Reservation User,Użytkownik rezerwacji hotelu,
+Hotel Room Reservation Item,Rezerwacja pokoju hotelowego,
+Hotel Settings,Ustawienia hotelu,
+Default Taxes and Charges,Domyślne podatków i opłat,
+Default Invoice Naming Series,Domyślna seria nazewnictwa faktur,
+Additional Salary,Dodatkowe wynagrodzenie,
+HR,HR,
+HR-ADS-.YY.-.MM.-,HR-ADS-.YY .-. MM.-,
+Salary Component,Wynagrodzenie Komponent,
+Overwrite Salary Structure Amount,Nadpisz ilość wynagrodzenia,
+Deduct Full Tax on Selected Payroll Date,Odliczenie pełnego podatku od wybranej daty płac,
+Payroll Date,Data płacy,
+Date on which this component is applied,Data zastosowania tego komponentu,
+Salary Slip,Pasek wynagrodzenia,
+Salary Component Type,Typ składnika wynagrodzenia,
+HR User,Kadry - użytkownik,
+Appointment Letter,List z terminem spotkania,
+Job Applicant,Aplikujący o pracę,
+Applicant Name,Imię Aplikanta,
+Appointment Date,Data spotkania,
+Appointment Letter Template,Szablon listu z terminami,
+Body,Ciało,
+Closing Notes,Uwagi końcowe,
+Appointment Letter content,Treść listu z terminem,
+Appraisal,Ocena,
+HR-APR-.YY.-.MM.,HR-APR-.YY.-.MM.,
+Appraisal Template,Szablon oceny,
+For Employee Name,Dla Imienia Pracownika,
+Goals,Cele,
+Total Score (Out of 5),Łączny wynik (w skali do 5),
+"Any other remarks, noteworthy effort that should go in the records.","Wszelkie inne uwagi, zauważyć, że powinien iść nakładu w ewidencji.",
+Appraisal Goal,Cel oceny,
+Key Responsibility Area,Kluczowy obszar obowiązków,
+Weightage (%),Waga/wiek (%),
+Score (0-5),Wynik (0-5),
+Score Earned,Ilość zdobytych punktów,
+Appraisal Template Title,Tytuł szablonu oceny,
+Appraisal Template Goal,Cel szablonu oceny,
+KRA,KRA,
+Key Performance Area,Kluczowy obszar wyników,
+HR-ATT-.YYYY.-,HR-ATT-.RRRR.-,
+On Leave,Na urlopie,
+Work From Home,Praca w domu,
+Leave Application,Wniosek o Nieobecność,
+Attendance Date,Data usługi,
+Attendance Request,Żądanie obecności,
+Late Entry,Późne wejście,
+Early Exit,Wczesne wyjście,
+Half Day Date,Pół Dzień Data,
+On Duty,Na służbie,
+Explanation,Wyjaśnienie,
+Compensatory Leave Request,Wniosek o urlop Wyrównawczy,
+Leave Allocation,Alokacja Nieobecności,
+Worked On Holiday,Pracowałem w wakacje,
+Work From Date,Praca od daty,
+Work End Date,Data zakończenia pracy,
+Email Sent To,Email wysłany do,
+Select Users,Wybierz użytkowników,
+Send Emails At,Wyślij pocztę elektroniczną w,
+Reminder,Przypomnienie,
+Daily Work Summary Group User,Codzienny użytkownik grupy roboczej,
+email,e-mail,
+Parent Department,Departament rodziców,
+Leave Block List,Lista Blokowanych Nieobecności,
+Days for which Holidays are blocked for this department.,Dni kiedy urlop jest zablokowany dla tego departamentu,
+Leave Approver,Zatwierdzający Nieobecność,
+Expense Approver,Osoba zatwierdzająca wydatki,
+Department Approver,Departament zatwierdzający,
+Approver,Osoba zatwierdzająca,
+Required Skills,Wymagane umiejętności,
+Skills,Umiejętności,
+Designation Skill,Umiejętność oznaczania,
+Skill,Umiejętność,
+Driver,Kierowca,
+HR-DRI-.YYYY.-,HR-DRI-.RRRR.-,
+Suspended,Zawieszony,
+Transporter,Transporter,
+Applicable for external driver,Dotyczy zewnętrznego sterownika,
+Cellphone Number,numer telefonu komórkowego,
+License Details,Szczegóły licencji,
+License Number,Numer licencji,
+Issuing Date,Data emisji,
+Driving License Categories,Kategorie prawa jazdy,
+Driving License Category,Kategoria prawa jazdy,
+Fleet Manager,Menedżer floty,
+Driver licence class,Klasa prawa jazdy,
+HR-EMP-,HR-EMP-,
+Employment Type,Typ zatrudnienia,
+Emergency Contact,Kontakt na wypadek nieszczęśliwych wypadków,
+Emergency Contact Name,kontakt do osoby w razie wypadku,
+Emergency Phone,Telefon bezpieczeństwa,
+ERPNext User,ERPNext Użytkownik,
+"System User (login) ID. If set, it will become default for all HR forms.","Użytkownik systemu (login) ID. Jeśli ustawiono, stanie się on domyślnym dla wszystkich formularzy HR",
+Create User Permission,Utwórz uprawnienia użytkownika,
+This will restrict user access to other employee records,To ograniczy dostęp użytkowników do innych rekordów pracowników,
+Joining Details,Łączenie szczegółów,
+Offer Date,Data oferty,
+Confirmation Date,Data potwierdzenia,
+Contract End Date,Data końcowa kontraktu,
+Notice (days),Wymówienie (dni),
+Date Of Retirement,Data przejścia na emeryturę,
+Department and Grade,Wydział i stopień,
+Reports to,Raporty do,
+Attendance and Leave Details,Frekwencja i szczegóły urlopu,
+Leave Policy,Polityka Nieobecności,
+Attendance Device ID (Biometric/RF tag ID),Identyfikator urządzenia obecności (identyfikator biometryczny / RF),
+Applicable Holiday List,Stosowna Lista Urlopów,
+Default Shift,Domyślne przesunięcie,
+Salary Details,Szczegóły wynagrodzeń,
+Salary Mode,Moduł Wynagrodzenia,
+Bank A/C No.,Numer rachunku bankowego,
+Health Insurance,Ubezpieczenie zdrowotne,
+Health Insurance Provider,Dostawca ubezpieczenia zdrowotnego,
+Health Insurance No,Numer ubezpieczenia zdrowotnego,
+Prefered Email,Zalecany email,
+Personal Email,Osobisty E-mail,
+Permanent Address Is,Stały adres to,
+Rented,Wynajęty,
+Owned,Zawłaszczony,
+Permanent Address,Stały adres,
+Prefered Contact Email,Preferowany kontakt e-mail,
+Company Email,Email do firmy,
+Provide Email Address registered in company,Podać adres e-mail zarejestrowany w firmie,
+Current Address Is,Obecny adres to,
+Current Address,Obecny adres,
+Personal Bio,Personal Bio,
+Bio / Cover Letter,Bio / List motywacyjny,
+Short biography for website and other publications.,Krótka notka na stronę i do innych publikacji,
+Passport Number,Numer Paszportu,
+Date of Issue,Data wydania,
+Place of Issue,Miejsce wydania,
+Widowed,Wdowiec / Wdowa,
+Family Background,Tło rodzinne,
+Health Details,Szczegóły Zdrowia,
+"Here you can maintain height, weight, allergies, medical concerns etc","Tutaj wypełnij i przechowaj dane takie jak wzrost, waga, alergie, problemy medyczne itd",
+Educational Qualification,Kwalifikacje edukacyjne,
+Previous Work Experience,Poprzednie doświadczenie zawodowe,
+External Work History,Historia Zewnętrzna Pracy,
+History In Company,Historia Firmy,
+Internal Work History,Wewnętrzne Historia Pracuj,
+Resignation Letter Date,Data wypowiedzenia,
+Relieving Date,Data zwolnienia,
+Reason for Leaving,Powód odejścia,
+Leave Encashed?,"Jesteś pewien, że chcesz wyjść z Wykupinych?",
+Encashment Date,Data Inkaso,
+New Workplace,Nowe Miejsce Pracy,
+HR-EAD-.YYYY.-,HR-EAD-.RRRR.-,
+Returned Amount,Zwrócona kwota,
+Claimed,Roszczenie,
+Advance Account,Rachunek zaawansowany,
+Employee Attendance Tool,Narzędzie Frekwencji,
+Unmarked Attendance,Obecność nieoznaczona,
+Employees HTML,Pracownicy HTML,
+Marked Attendance,Zaznaczona Obecność,
+Marked Attendance HTML,Zaznaczona Obecność HTML,
+Employee Benefit Application,Świadczenie pracownicze,
+Max Benefits (Yearly),Maksymalne korzyści (rocznie),
+Remaining Benefits (Yearly),Pozostałe korzyści (rocznie),
+Payroll Period,Okres płacy,
+Benefits Applied,Korzyści zastosowane,
+Dispensed Amount (Pro-rated),Dawka dodana (zaszeregowana),
+Employee Benefit Application Detail,Szczegóły zastosowania świadczeń pracowniczych,
+Earning Component,Zarabianie na komponent,
+Pay Against Benefit Claim,Zapłać na poczet zasiłku,
+Max Benefit Amount,Kwota maksymalnego świadczenia,
+Employee Benefit Claim,Świadczenie pracownicze,
+Claim Date,Data roszczenia,
+Benefit Type and Amount,Rodzaj świadczenia i kwota,
+Claim Benefit For,Zasiłek roszczenia dla,
+Max Amount Eligible,Maksymalna kwota kwalifikująca się,
+Expense Proof,Dowód wydatków,
+Employee Boarding Activity,Działalność Boarding pracownika,
+Activity Name,Nazwa działania,
+Task Weight,Zadanie waga,
+Required for Employee Creation,Wymagany w przypadku tworzenia pracowników,
+Applicable in the case of Employee Onboarding,Ma zastosowanie w przypadku wprowadzenia pracownika na rynek,
+Employee Checkin,Checkin pracownika,
+Log Type,Typ dziennika,
+OUT,NA ZEWNĄTRZ,
+Location / Device ID,Lokalizacja / identyfikator urządzenia,
+Skip Auto Attendance,Pomiń automatyczne uczestnictwo,
+Shift Start,Shift Start,
+Shift End,Shift End,
+Shift Actual Start,Shift Actual Start,
+Shift Actual End,Shift Actual End,
+Employee Education,Wykształcenie pracownika,
+School/University,Szkoła/Uniwersytet,
+Graduate,Absolwent,
+Post Graduate,Podyplomowe,
+Under Graduate,Absolwent,
+Year of Passing,Mijający rok,
+Major/Optional Subjects,Główne/Opcjonalne Tematy,
+Employee External Work History,Historia zatrudnienia pracownika poza firmą,
+Total Experience,Całkowita kwota wydatków,
+Default Leave Policy,Domyślna Polityka Nieobecności,
+Default Salary Structure,Domyślna struktura wynagrodzenia,
+Employee Group Table,Tabela grup pracowników,
+ERPNext User ID,ERPNext Identyfikator użytkownika,
+Employee Health Insurance,Ubezpieczenie zdrowotne pracownika,
+Health Insurance Name,Nazwa ubezpieczenia zdrowotnego,
+Employee Incentive,Zachęta dla pracowników,
+Incentive Amount,Kwota motywacyjna,
+Employee Internal Work History,Historia zatrudnienia pracownika w firmie,
+Employee Onboarding,Wprowadzanie pracowników,
+Notify users by email,Powiadom użytkowników pocztą e-mail,
+Employee Onboarding Template,Szablon do wprowadzania pracowników,
+Activities,Zajęcia,
+Employee Onboarding Activity,Aktywność pracownika na pokładzie,
+Employee Other Income,Inne dochody pracownika,
+Employee Promotion,Promocja pracowników,
+Promotion Date,Data promocji,
+Employee Promotion Details,Szczegóły promocji pracowników,
+Employee Promotion Detail,Szczegóły promocji pracowników,
+Employee Property History,Historia nieruchomości pracownika,
+Employee Separation,Separacja pracowników,
+Employee Separation Template,Szablon separacji pracowników,
+Exit Interview Summary,Wyjdź z podsumowania wywiadu,
+Employee Skill,Umiejętność pracownika,
+Proficiency,Biegłość,
+Evaluation Date,Data oceny,
+Employee Skill Map,Mapa umiejętności pracowników,
+Employee Skills,Umiejętności pracowników,
+Trainings,Szkolenia,
+Employee Tax Exemption Category,Kategoria zwolnienia z podatku dochodowego od pracowników,
+Max Exemption Amount,Maksymalna kwota zwolnienia,
+Employee Tax Exemption Declaration,Deklaracja zwolnienia z podatku od pracowników,
+Declarations,Deklaracje,
+Total Declared Amount,Całkowita zadeklarowana kwota,
+Total Exemption Amount,Całkowita kwota zwolnienia,
+Employee Tax Exemption Declaration Category,Kategoria deklaracji zwolnienia podatkowego dla pracowników,
+Exemption Sub Category,Kategoria zwolnienia,
+Exemption Category,Kategoria zwolnienia,
+Maximum Exempted Amount,Maksymalna kwota zwolniona,
+Declared Amount,Zadeklarowana kwota,
+Employee Tax Exemption Proof Submission,Świadectwo zwolnienia podatkowego dla pracowników,
+Submission Date,Termin składania,
+Tax Exemption Proofs,Dowody zwolnienia podatkowego,
+Total Actual Amount,Całkowita rzeczywista kwota,
+Employee Tax Exemption Proof Submission Detail,Szczegółowe informacje dotyczące złożenia zeznania podatkowego dla pracowników,
+Maximum Exemption Amount,Maksymalna kwota zwolnienia,
+Type of Proof,Rodzaj dowodu,
+Actual Amount,Rzeczywista kwota,
+Employee Tax Exemption Sub Category,Podkategoria zwolnień podatkowych dla pracowników,
+Tax Exemption Category,Kategoria zwolnienia podatkowego,
+Employee Training,Szkolenie pracowników,
+Training Date,Data szkolenia,
+Employee Transfer,Przeniesienie pracownika,
+Transfer Date,Data przeniesienia,
+Employee Transfer Details,Dane dotyczące przeniesienia pracownika,
+Employee Transfer Detail,Dane dotyczące przeniesienia pracownika,
+Re-allocate Leaves,Realokuj Nieobeności,
+Create New Employee Id,Utwórz nowy identyfikator pracownika,
+New Employee ID,Nowy identyfikator pracownika,
+Employee Transfer Property,Usługa przenoszenia pracowniczych,
+HR-EXP-.YYYY.-,HR-EXP-.RRRR.-,
+Expense Taxes and Charges,Podatki i opłaty z tytułu kosztów,
+Total Sanctioned Amount,Całkowita kwota uznań,
+Total Advance Amount,Łączna kwota zaliczki,
+Total Claimed Amount,Całkowita kwota roszczeń,
+Total Amount Reimbursed,Całkowitej kwoty zwrotów,
+Vehicle Log,pojazd Log,
+Employees Email Id,Email ID pracownika,
+More Details,Więcej szczegółów,
+Expense Claim Account,Konto Koszty Roszczenie,
+Expense Claim Advance,Advance Claim Advance,
+Unclaimed amount,Nie zgłoszona kwota,
+Expense Claim Detail,Szczegóły o zwrotach kosztów,
+Expense Date,Data wydatku,
+Expense Claim Type,Typ Zwrotu Kosztów,
+Holiday List Name,Nazwa dla Listy Świąt,
+Total Holidays,Suma dni świątecznych,
+Add Weekly Holidays,Dodaj cotygodniowe święta,
+Weekly Off,Tygodniowy wyłączony,
+Add to Holidays,Dodaj do świąt,
+Holidays,Wakacje,
+Clear Table,Wyczyść tabelę,
+HR Settings,Ustawienia HR,
+Employee Settings,Ustawienia pracownika,
+Retirement Age,Wiek emerytalny,
+Enter retirement age in years,Podaj wiek emerytalny w latach,
+Stop Birthday Reminders,Zatrzymaj przypomnienia o urodzinach,
+Expense Approver Mandatory In Expense Claim,Potwierdzenie wydatków Obowiązkowe w rachunku kosztów,
+Payroll Settings,Ustawienia Listy Płac,
+Leave,Pozostawiać,
+Max working hours against Timesheet,Maksymalny czas pracy przed grafiku,
+Include holidays in Total no. of Working Days,Dolicz święta do całkowitej liczby dni pracujących,
+"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Jeśli zaznaczone, Całkowita liczba Dni Roboczych obejmie święta, a to zmniejsza wartość Wynagrodzenie za dzień",
+"If checked, hides and disables Rounded Total field in Salary Slips","Jeśli zaznaczone, ukrywa i wyłącza pole Zaokrąglona suma w kuponach wynagrodzeń",
+The fraction of daily wages to be paid for half-day attendance,Część dziennego wynagrodzenia za obecność na pół dnia,
+Email Salary Slip to Employee,Email Wynagrodzenie Slip pracownikowi,
+Emails salary slip to employee based on preferred email selected in Employee,Emaile wynagrodzenia poślizgu pracownikowi na podstawie wybranego w korzystnej email Pracownika,
+Encrypt Salary Slips in Emails,Szyfruj poświadczenia wynagrodzenia w wiadomościach e-mail,
+"The salary slip emailed to the employee will be password protected, the password will be generated based on the password policy.","Ślad wynagrodzenia przesłany pocztą elektroniczną do pracownika będzie chroniony hasłem, hasło zostanie wygenerowane na podstawie polityki haseł.",
+Password Policy,Polityka haseł,
+<b>Example:</b> SAL-{first_name}-{date_of_birth.year} <br>This will generate a password like SAL-Jane-1972,<b>Przykład:</b> SAL- {first_name} - {date_of_birth.year} <br> Spowoduje to wygenerowanie hasła takiego jak SAL-Jane-1972,
+Leave Settings,Ustawienia Nieobecności,
+Leave Approval Notification Template,Pozostaw szablon powiadomienia o zatwierdzeniu,
+Leave Status Notification Template,Pozostaw szablon powiadomienia o statusie,
+Role Allowed to Create Backdated Leave Application,Rola dozwolona do utworzenia aplikacji urlopowej z datą wsteczną,
+Leave Approver Mandatory In Leave Application,Pozostaw zatwierdzającego obowiązkowo w aplikacji opuszczającej,
+Show Leaves Of All Department Members In Calendar,Pokaż Nieobecności Wszystkich Członków Działu w Kalendarzu,
+Auto Leave Encashment,Auto Leave Encashment,
+Hiring Settings,Ustawienia wynajmu,
+Check Vacancies On Job Offer Creation,Sprawdź oferty pracy w tworzeniu oferty pracy,
+Identification Document Type,Typ dokumentu tożsamości,
+Effective from,Obowiązuje od,
+Allow Tax Exemption,Zezwalaj na zwolnienie z podatku,
+"If enabled, Tax Exemption Declaration will be considered for income tax calculation.","Jeśli ta opcja jest włączona, deklaracja zwolnienia z podatku będzie brana pod uwagę przy obliczaniu podatku dochodowego.",
+Standard Tax Exemption Amount,Kwota zwolnienia z podatku standardowego,
+Taxable Salary Slabs,Podatki podlegające opodatkowaniu,
+Taxes and Charges on Income Tax,Podatki i opłaty od podatku dochodowego,
+Other Taxes and Charges,Inne podatki i opłaty,
+Income Tax Slab Other Charges,Płyta podatku dochodowego Inne opłaty,
+Min Taxable Income,Min. Dochód podlegający opodatkowaniu,
+Max Taxable Income,Maksymalny dochód podlegający opodatkowaniu,
+Applicant for a Job,Aplikant do Pracy,
+Accepted,Przyjęte,
+Job Opening,Otwarcie naboru na stanowisko,
+Cover Letter,List motywacyjny,
+Resume Attachment,W skrócie Załącznik,
+Job Applicant Source,Źródło wniosku o pracę,
+Applicant Email Address,Adres e-mail wnioskodawcy,
+Awaiting Response,Oczekuje na Odpowiedź,
+Job Offer Terms,Warunki oferty pracy,
+Select Terms and Conditions,Wybierz Regulamin,
+Printing Details,Szczegóły Wydruku,
+Job Offer Term,Okres oferty pracy,
+Offer Term,Oferta Term,
+Value / Description,Wartość / Opis,
+Description of a Job Opening,Opis Ogłoszenia o Pracę,
+Job Title,Nazwa stanowiska pracy,
+Staffing Plan,Plan zatrudnienia,
+Planned number of Positions,Planowana liczba pozycji,
+"Job profile, qualifications required etc.","Profil stanowiska pracy, wymagane kwalifikacje itp.",
+HR-LAL-.YYYY.-,HR-LAL-.RRRR.-,
+Allocation,Przydział,
+New Leaves Allocated,Nowe Nieobecności Zaalokowane,
+Add unused leaves from previous allocations,Dodaj niewykorzystane nieobecności z poprzednich alokacji,
+Unused leaves,Niewykorzystane Nieobecności,
+Total Leaves Allocated,Całkowita ilość przyznanych dni zwolnienia od pracy,
+Total Leaves Encashed,Total Leaves Encashed,
+Leave Period,Okres Nieobecności,
+Apply / Approve Leaves,Zastosuj / Zatwierdź Nieobecności,
+HR-LAP-.YYYY.-,HR-LAP-.YYYY.-,
+Leave Balance Before Application,Status Nieobecności przed Wnioskiem,
+Total Leave Days,Całkowita liczba Dni Nieobecności,
+Leave Approver Name,Nazwa Zatwierdzającego Nieobecność,
+Follow via Email,Odpowiedz za pomocą E-maila,
+Block Holidays on important days.,Blok Wakacje na ważne dni.,
+Leave Block List Name,Nazwa Listy Blokowanych Nieobecności,
+Applies to Company,Dotyczy Firmy,
+"If not checked, the list will have to be added to each Department where it has to be applied.","Jeśli nie jest zaznaczone, lista będzie musiała być dodana do każdego Działu, w którym ma zostać zastosowany.",
+Block Days,Zablokowany Dzień,
+Stop users from making Leave Applications on following days.,Zatrzymaj możliwość składania zwolnienia chorobowego użytkownikom w następujące dni.,
+Leave Block List Dates,Daty dopuszczenia na Liście Blokowanych Nieobecności,
+Allow Users,Zezwól Użytkownikom,
+Leave Block List Allowed,Dopuszczone na Liście Blokowanych Nieobecności,
+Leave Block List Allow,Dopuść na Liście Blokowanych Nieobecności,
+Allow User,Zezwól Użytkownikowi,
+Leave Block List Date,Data dopuszczenia na Liście Blokowanych Nieobecności,
+Block Date,Zablokowana Data,
+Leave Control Panel,Panel do obsługi Nieobecności,
+Select Employees,Wybierz Pracownicy,
+Employment Type (optional),Rodzaj zatrudnienia (opcjonalnie),
+Branch (optional),Oddział (opcjonalnie),
+Department (optional),Dział (opcjonalnie),
+Designation (optional),Oznaczenie (opcjonalnie),
+Employee Grade (optional),Stopień pracownika (opcjonalnie),
+Employee (optional),Pracownik (opcjonalnie),
+Allocate Leaves,Przydziel liście,
+Carry Forward,Przeniesienie,
+Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,Proszę wybrać Przeniesienie jeżeli chcesz uwzględnić balans poprzedniego roku rozliczeniowego do tego roku rozliczeniowego,
+New Leaves Allocated (In Days),Nowe Nieobecności Zaalokowane (W Dniach),
+Allocate,Przydziel,
+Leave Balance,Pozostaw saldo,
+Encashable days,Szykowne dni,
+Encashment Amount,Kwota rabatu,
+Leave Ledger Entry,Pozostaw wpis księgi głównej,
+Transaction Name,Nazwa transakcji,
+Is Expired,Straciła ważność,
+Is Leave Without Pay,jest Urlopem Bezpłatnym,
+Holiday List for Optional Leave,Lista urlopowa dla Opcjonalnej Nieobecności,
+Leave Allocations,Alokacje Nieobecności,
+Leave Policy Details,Szczegóły Polityki Nieobecności,
+Leave Policy Detail,Szczegół Polityki Nieobecności,
+Annual Allocation,Roczna alokacja,
+Leave Type Name,Nazwa Typu Urlopu,
+Max Leaves Allowed,"Maksymalna, dozwolona liczba Nieobecności",
+Applicable After (Working Days),Dotyczy After (dni robocze),
+Maximum Continuous Days Applicable,Maksymalne ciągłe dni obowiązujące,
+Is Optional Leave,jest Nieobecnością Opcjonalną,
+Allow Negative Balance,Dozwolony ujemny bilans,
+Include holidays within leaves as leaves,Uwzględniaj święta w ramach Nieobecności,
+Is Compensatory,Jest kompensacyjny,
+Maximum Carry Forwarded Leaves,Maksymalna liczba przeniesionych liści,
+Expire Carry Forwarded Leaves (Days),Wygasają przenoszenie przekazanych liści (dni),
+Calculated in days,Obliczany w dniach,
+Encashment,Napad,
+Allow Encashment,Zezwól na Osadzanie,
+Encashment Threshold Days,Progi prolongaty,
+Earned Leave,Urlop w ramach nagrody,
+Is Earned Leave,jest Urlopem w ramach Nagrody,
+Earned Leave Frequency,Częstotliwość Urlopu w ramach nagrody,
+Rounding,Zaokrąglanie,
+Payroll Employee Detail,Szczegóły dotyczące kadry płacowej,
+Payroll Frequency,Częstotliwość Płace,
+Fortnightly,Dwutygodniowy,
+Bimonthly,Dwumiesięczny,
+Employees,Pracowników,
+Number Of Employees,Liczba pracowników,
+Validate Attendance,Zweryfikuj Frekfencję,
+Salary Slip Based on Timesheet,Slip Wynagrodzenie podstawie grafiku,
+Select Payroll Period,Wybierz Okres Payroll,
+Deduct Tax For Unclaimed Employee Benefits,Odliczanie podatku za nieodebrane świadczenia pracownicze,
+Deduct Tax For Unsubmitted Tax Exemption Proof,Odliczanie podatku za nieprzedstawiony dowód zwolnienia podatkowego,
+Select Payment Account to make Bank Entry,Wybierz Konto Płatność aby bankowego Entry,
+Salary Slips Created,Utworzono zarobki,
+Salary Slips Submitted,Przesłane wynagrodzenie,
+Payroll Periods,Okresy płac,
+Payroll Period Date,Okres listy płac,
+Purpose of Travel,Cel podróży,
+Retention Bonus,Premia z zatrzymania,
+Bonus Payment Date,Data wypłaty bonusu,
+Bonus Amount,Kwota Bonusu,
+Abbr,Skrót,
+Depends on Payment Days,Zależy od dni płatności,
+Is Tax Applicable,Podatek obowiązuje,
+Variable Based On Taxable Salary,Zmienna oparta na podlegającym opodatkowaniu wynagrodzeniu,
+Exempted from Income Tax,Zwolnione z podatku dochodowego,
+Round to the Nearest Integer,Zaokrąglij do najbliższej liczby całkowitej,
+Statistical Component,Składnik statystyczny,
+"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Jeśli zostanie wybrana, wartość określona lub obliczona w tym składniku nie przyczyni się do zarobków ani odliczeń. Jednak wartością tę można odwoływać się do innych składników, które można dodawać lub potrącać.",
+Do Not Include in Total,Nie uwzględniaj w sumie,
+Flexible Benefits,Elastyczne korzyści,
+Is Flexible Benefit,Elastyczna korzyść,
+Max Benefit Amount (Yearly),Kwota maksymalnego świadczenia (rocznie),
+Only Tax Impact (Cannot Claim But Part of Taxable Income),Tylko wpływ podatkowy (nie można domagać się części dochodu podlegającego opodatkowaniu),
+Create Separate Payment Entry Against Benefit Claim,Utwórz oddzielne zgłoszenie wpłaty na poczet roszczenia o zasiłek,
+Condition and Formula,Stan i wzór,
+Amount based on formula,Kwota wg wzoru,
+Formula,Formuła,
+Salary Detail,Wynagrodzenie Szczegóły,
+Component,Składnik,
+Do not include in total,Nie obejmują łącznie,
+Default Amount,Domyślnie Kwota,
+Additional Amount,Dodatkowa ilość,
+Tax on flexible benefit,Podatek od elastycznej korzyści,
+Tax on additional salary,Podatek od dodatkowego wynagrodzenia,
+Salary Structure,Struktura Wynagrodzenia,
+Working Days,Dni robocze,
+Salary Slip Timesheet,Slip Wynagrodzenie grafiku,
+Total Working Hours,Całkowita liczba godzin pracy,
+Hour Rate,Stawka godzinowa,
+Bank Account No.,Nr konta bankowego,
+Earning & Deduction,Dochód i Odliczenie,
+Earnings,Dochody,
+Deductions,Odliczenia,
+Loan repayment,Spłata pożyczki,
+Employee Loan,pracownik Kredyt,
+Total Principal Amount,Łączna kwota główna,
+Total Interest Amount,Łączna kwota odsetek,
+Total Loan Repayment,Suma spłaty kredytu,
+net pay info,Informacje o wynagrodzeniu netto,
+Gross Pay - Total Deduction - Loan Repayment,Gross Pay - Razem Odliczenie - Spłata kredytu,
+Total in words,Ogółem słownie,
+Net Pay (in words) will be visible once you save the Salary Slip.,Wynagrodzenie netto (słownie) będzie widoczna po zapisaniu na Liście Płac.,
+Salary Component for timesheet based payroll.,Składnik wynagrodzenia za płac opartego grafik.,
+Leave Encashment Amount Per Day,Zostaw kwotę za dzieło na dzień,
+Max Benefits (Amount),Maksymalne korzyści (kwota),
+Salary breakup based on Earning and Deduction.,Średnie wynagrodzenie w oparciu o zarobki i odliczenia,
+Total Earning,Całkowita kwota zarobku,
+Salary Structure Assignment,Przydział struktury wynagrodzeń,
+Shift Assignment,Przydział Shift,
+Shift Type,Typ zmiany,
+Shift Request,Żądanie zmiany,
+Enable Auto Attendance,Włącz automatyczne uczestnictwo,
+Mark attendance based on 'Employee Checkin' for Employees assigned to this shift.,Oznacz obecność na podstawie „Checkin pracownika” dla pracowników przypisanych do tej zmiany.,
+Auto Attendance Settings,Ustawienia automatycznej obecności,
+Determine Check-in and Check-out,Określ odprawę i wymeldowanie,
+Alternating entries as IN and OUT during the same shift,Naprzemienne wpisy jako IN i OUT podczas tej samej zmiany,
+Strictly based on Log Type in Employee Checkin,Ściśle na podstawie typu dziennika w Checkin pracownika,
+Working Hours Calculation Based On,Obliczanie godzin pracy na podstawie,
+First Check-in and Last Check-out,Pierwsze zameldowanie i ostatnie wymeldowanie,
+Every Valid Check-in and Check-out,Każde ważne zameldowanie i wymeldowanie,
+Begin check-in before shift start time (in minutes),Rozpocznij odprawę przed czasem rozpoczęcia zmiany (w minutach),
+The time before the shift start time during which Employee Check-in is considered for attendance.,"Czas przed rozpoczęciem zmiany, podczas którego odprawa pracownicza jest brana pod uwagę przy uczestnictwie.",
+Allow check-out after shift end time (in minutes),Zezwól na wymeldowanie po zakończeniu czasu zmiany (w minutach),
+Time after the end of shift during which check-out is considered for attendance.,"Czas po zakończeniu zmiany, w trakcie którego wymeldowanie jest brane pod uwagę.",
+Working Hours Threshold for Half Day,Próg godzin pracy na pół dnia,
+Working hours below which Half Day is marked. (Zero to disable),"Godziny pracy, poniżej których zaznaczono pół dnia. (Zero, aby wyłączyć)",
+Working Hours Threshold for Absent,Próg godzin pracy dla nieobecności,
+Working hours below which Absent is marked. (Zero to disable),"Godziny pracy poniżej których nieobecność jest zaznaczona. (Zero, aby wyłączyć)",
+Process Attendance After,Uczestnictwo w procesie po,
+Attendance will be marked automatically only after this date.,Obecność zostanie oznaczona automatycznie dopiero po tej dacie.,
+Last Sync of Checkin,Ostatnia synchronizacja odprawy,
+Last Known Successful Sync of Employee Checkin. Reset this only if you are sure that all Logs are synced from all the locations. Please don't modify this if you are unsure.,"Ostatnia znana udana synchronizacja odprawy pracownika. Zresetuj to tylko wtedy, gdy masz pewność, że wszystkie dzienniki są synchronizowane ze wszystkich lokalizacji. Nie zmieniaj tego, jeśli nie jesteś pewien.",
+Grace Period Settings For Auto Attendance,Ustawienia okresu Grace dla automatycznej obecności,
+Enable Entry Grace Period,Włącz okres ważności wpisu,
+Late Entry Grace Period,Okres późnego wejścia,
+The time after the shift start time when check-in is considered as late (in minutes).,"Czas po godzinie rozpoczęcia zmiany, gdy odprawa jest uważana za późną (w minutach).",
+Enable Exit Grace Period,Włącz okres wyjścia Grace,
+Early Exit Grace Period,Wczesny okres wyjścia z inwestycji,
+The time before the shift end time when check-out is considered as early (in minutes).,"Czas przed czasem zakończenia zmiany, gdy wymeldowanie jest uważane za wczesne (w minutach).",
+Skill Name,Nazwa umiejętności,
+Staffing Plan Details,Szczegółowy plan zatrudnienia,
+Staffing Plan Detail,Szczegółowy plan zatrudnienia,
+Total Estimated Budget,Całkowity szacunkowy budżet,
+Vacancies,Wakaty,
+Estimated Cost Per Position,Szacowany koszt na stanowisko,
+Total Estimated Cost,Całkowity szacunkowy koszt,
+Current Count,Bieżąca liczba,
+Current Openings,Aktualne otwarcia,
+Number Of Positions,Liczba pozycji,
+Taxable Salary Slab,Podatki podlegające opodatkowaniu,
+From Amount,Od kwoty,
+To Amount,Do kwoty,
+Percent Deduction,Odliczenie procentowe,
+Training Program,Program treningowy,
+Event Status,zdarzenia,
+Has Certificate,Ma certyfikat,
+Seminar,Seminarium,
+Theory,Teoria,
+Workshop,Warsztat,
+Conference,Konferencja,
+Exam,Egzamin,
+Internet,Internet,
+Self-Study,Samokształcenie,
+Advance,Zaliczka,
+Trainer Name,Nazwa Trainer,
+Trainer Email,Trener email,
+Attendees,Uczestnicy,
+Employee Emails,E-maile z pracownikami,
+Training Event Employee,Training Event urzędnik,
+Invited,Zaproszony,
+Feedback Submitted,Zgłoszenie Zgłoszony,
+Optional,Opcjonalny,
+Training Result Employee,Wynik szkolenia pracowników,
+Travel Itinerary,Plan podróży,
+Travel From,Podróżuj z,
+Travel To,Podróż do,
+Mode of Travel,Tryb podróży,
+Flight,Lot,
+Train,Pociąg,
+Taxi,Taxi,
+Rented Car,Wynajęty samochód,
+Meal Preference,Preferencje Posiłków,
+Vegetarian,Wegetariański,
+Non-Vegetarian,Nie wegetarianskie,
+Gluten Free,Bezglutenowe,
+Non Diary,Non Diary,
+Travel Advance Required,Wymagane wcześniejsze podróżowanie,
+Departure Datetime,Data wyjazdu Datetime,
+Arrival Datetime,Przybycie Datetime,
+Lodging Required,Wymagane zakwaterowanie,
+Preferred Area for Lodging,Preferowany obszar zakwaterowania,
+Check-in Date,Sprawdź w terminie,
+Check-out Date,Sprawdź datę,
+Travel Request,Wniosek o podróż,
+Travel Type,Rodzaj podróży,
+Domestic,Krajowy,
+International,Międzynarodowy,
+Travel Funding,Finansowanie podróży,
+Require Full Funding,Wymagaj pełnego finansowania,
+Fully Sponsored,W pełni sponsorowane,
+"Partially Sponsored, Require Partial Funding","Częściowo sponsorowane, wymagające częściowego finansowania",
+Copy of Invitation/Announcement,Kopia zaproszenia / ogłoszenia,
+"Details of Sponsor (Name, Location)","Dane sponsora (nazwa, lokalizacja)",
+Identification Document Number,Numer identyfikacyjny dokumentu,
+Any other details,Wszelkie inne szczegóły,
+Costing Details,Szczegóły dotyczące kalkulacji kosztów,
+Costing,Zestawienie kosztów,
+Event Details,Szczegóły wydarzenia,
+Name of Organizer,Nazwa organizatora,
+Address of Organizer,Adres Organizatora,
+Travel Request Costing,Koszt wniosku podróży,
+Expense Type,Typ wydatków,
+Sponsored Amount,Sponsorowana kwota,
+Funded Amount,Kwota dofinansowania,
+Upload Attendance,Wyślij obecność,
+Attendance From Date,Obecność od Daty,
+Attendance To Date,Obecność do Daty,
+Get Template,Pobierz szablon,
+Import Attendance,Importuj Frekwencję,
+Upload HTML,Wyślij HTML,
+Vehicle,Pojazd,
+License Plate,Tablica rejestracyjna,
+Odometer Value (Last),Drogomierz Wartość (Ostatni),
+Acquisition Date,Data nabycia,
+Chassis No,Podwozie Nie,
+Vehicle Value,Wartość pojazdu,
+Insurance Details,Szczegóły ubezpieczenia,
+Insurance Company,Firma ubezpieczeniowa,
+Policy No,Polityka nr,
+Additional Details,Dodatkowe Szczegóły,
+Fuel Type,Typ paliwa,
+Petrol,Benzyna,
+Diesel,Diesel,
+Natural Gas,Gazu ziemnego,
+Electric,Elektryczny,
+Fuel UOM,Jednostka miary paliwa,
+Last Carbon Check,Ostatni Carbon Sprawdź,
+Wheels,Koła,
+Doors,drzwi,
+HR-VLOG-.YYYY.-,HR-VLOG-.YYYY.-,
+Odometer Reading,Stan licznika,
+Current Odometer value ,Aktualna wartość licznika przebiegu,
+last Odometer Value ,ostatnia wartość licznika przebiegu,
+Refuelling Details,Szczegóły tankowania,
+Invoice Ref,faktura Ref,
+Service Details,Szczegóły usługi,
+Service Detail,Szczegóły usługi,
+Vehicle Service,Obsługa pojazdu,
+Service Item,service Element,
+Brake Oil,Olej hamulcowy,
+Brake Pad,Klocek hamulcowy,
+Clutch Plate,sprzęgło,
+Engine Oil,Olej silnikowy,
+Oil Change,Wymiana oleju,
+Inspection,Kontrola,
+Mileage,Przebieg,
+Hub Tracked Item,Hub Tracked Item,
+Hub Node,Hub Węzeł,
+Image List,Lista obrazów,
+Item Manager,Pozycja menedżera,
+Hub User,Użytkownik centrum,
+Hub Password,Hasło koncentratora,
+Hub Users,Użytkownicy centrum,
+Marketplace Settings,Ustawienia Marketplace,
+Disable Marketplace,Wyłącz Marketplace,
+Marketplace URL (to hide and update label),Adres URL rynku (aby ukryć i zaktualizować etykietę),
+Registered,Zarejestrowany,
+Sync in Progress,Synchronizacja w toku,
+Hub Seller Name,Nazwa sprzedawcy Hub,
+Custom Data,Dane niestandardowe,
+Member,Członek,
+Partially Disbursed,częściowo wypłacona,
+Loan Closure Requested,Zażądano zamknięcia pożyczki,
+Repay From Salary,Spłaty z pensji,
+Loan Details,pożyczka Szczegóły,
+Loan Type,Rodzaj kredytu,
+Loan Amount,Kwota kredytu,
+Is Secured Loan,Jest zabezpieczona pożyczka,
+Rate of Interest (%) / Year,Stopa procentowa (% / rok),
+Disbursement Date,wypłata Data,
+Disbursed Amount,Kwota wypłacona,
+Is Term Loan,Jest pożyczką terminową,
+Repayment Method,Sposób spłaty,
+Repay Fixed Amount per Period,Spłacić ustaloną kwotę za okres,
+Repay Over Number of Periods,Spłaty przez liczbę okresów,
+Repayment Period in Months,Spłata Okres w miesiącach,
+Monthly Repayment Amount,Miesięczna kwota spłaty,
+Repayment Start Date,Data rozpoczęcia spłaty,
+Loan Security Details,Szczegóły bezpieczeństwa pożyczki,
+Maximum Loan Value,Maksymalna wartość pożyczki,
+Account Info,Informacje o koncie,
+Loan Account,Konto kredytowe,
+Interest Income Account,Konto przychodów odsetkowych,
+Penalty Income Account,Rachunek dochodów z kar,
+Repayment Schedule,Harmonogram spłaty,
+Total Payable Amount,Całkowita należna kwota,
+Total Principal Paid,Łącznie wypłacone główne zlecenie,
+Total Interest Payable,Razem odsetki płatne,
+Total Amount Paid,Łączna kwota zapłacona,
+Loan Manager,Menedżer pożyczek,
+Loan Info,pożyczka Info,
+Rate of Interest,Stopa procentowa,
+Proposed Pledges,Proponowane zobowiązania,
+Maximum Loan Amount,Maksymalna kwota kredytu,
+Repayment Info,Informacje spłata,
+Total Payable Interest,Całkowita zapłata odsetek,
+Against Loan ,Przed pożyczką,
+Loan Interest Accrual,Narosłe odsetki od pożyczki,
+Amounts,Kwoty,
+Pending Principal Amount,Oczekująca kwota główna,
+Payable Principal Amount,Kwota główna do zapłaty,
+Paid Principal Amount,Zapłacona kwota główna,
+Paid Interest Amount,Kwota zapłaconych odsetek,
+Process Loan Interest Accrual,Przetwarzanie naliczonych odsetek od kredytu,
+Repayment Schedule Name,Nazwa harmonogramu spłaty,
+Regular Payment,Regularna płatność,
+Loan Closure,Zamknięcie pożyczki,
+Payment Details,Szczegóły płatności,
+Interest Payable,Odsetki płatne,
+Amount Paid,Kwota zapłacona,
+Principal Amount Paid,Kwota główna wypłacona,
+Repayment Details,Szczegóły spłaty,
+Loan Repayment Detail,Szczegóły spłaty pożyczki,
+Loan Security Name,Nazwa zabezpieczenia pożyczki,
+Unit Of Measure,Jednostka miary,
+Loan Security Code,Kod bezpieczeństwa pożyczki,
+Loan Security Type,Rodzaj zabezpieczenia pożyczki,
+Haircut %,Strzyżenie%,
+Loan  Details,Szczegóły pożyczki,
+Unpledged,Niepowiązane,
+Pledged,Obiecał,
+Partially Pledged,Częściowo obiecane,
+Securities,Papiery wartościowe,
+Total Security Value,Całkowita wartość bezpieczeństwa,
+Loan Security Shortfall,Niedobór bezpieczeństwa pożyczki,
+Loan ,Pożyczka,
+Shortfall Time,Czas niedoboru,
+America/New_York,America / New_York,
+Shortfall Amount,Kwota niedoboru,
+Security Value ,Wartość bezpieczeństwa,
+Process Loan Security Shortfall,Niedobór bezpieczeństwa pożyczki procesowej,
+Loan To Value Ratio,Wskaźnik pożyczki do wartości,
+Unpledge Time,Unpledge Time,
+Loan Name,pożyczka Nazwa,
+Rate of Interest (%) Yearly,Stopa procentowa (%) Roczne,
+Penalty Interest Rate (%) Per Day,Kara odsetkowa (%) dziennie,
+Penalty Interest Rate is levied on the pending interest amount on a daily basis in case of delayed repayment ,Kara odsetkowa naliczana jest codziennie od oczekującej kwoty odsetek w przypadku opóźnionej spłaty,
+Grace Period in Days,Okres karencji w dniach,
+No. of days from due date until which penalty won't be charged in case of delay in loan repayment,"Liczba dni od daty wymagalności, do której kara nie będzie naliczana w przypadku opóźnienia w spłacie kredytu",
+Pledge,Zastaw,
+Post Haircut Amount,Kwota po ostrzyżeniu,
+Process Type,Typ procesu,
+Update Time,Czas aktualizacji,
+Proposed Pledge,Proponowane zobowiązanie,
+Total Payment,Całkowita płatność,
+Balance Loan Amount,Kwota salda kredytu,
+Is Accrued,Jest naliczony,
+Salary Slip Loan,Salary Slip Loan,
+Loan Repayment Entry,Wpis spłaty kredytu,
+Sanctioned Loan Amount,Kwota udzielonej sankcji,
+Sanctioned Amount Limit,Sankcjonowany limit kwoty,
+Unpledge,Unpledge,
+Haircut,Ostrzyżenie,
+MAT-MSH-.YYYY.-,MAT-MSH-.YYYY.-,
+Generate Schedule,Utwórz Harmonogram,
+Schedules,Harmonogramy,
+Maintenance Schedule Detail,Szczegóły Planu Konserwacji,
+Scheduled Date,Zaplanowana Data,
+Actual Date,Rzeczywista Data,
+Maintenance Schedule Item,Przedmiot Planu Konserwacji,
+Random,Losowy,
+No of Visits,Numer wizyt,
+MAT-MVS-.YYYY.-,MAT-MVS-.YYYY.-,
+Maintenance Date,Data Konserwacji,
+Maintenance Time,Czas Konserwacji,
+Completion Status,Status ukończenia,
+Partially Completed,Częściowo Ukończony,
+Fully Completed,Całkowicie ukończono,
+Unscheduled,Nieplanowany,
+Breakdown,Rozkład,
+Purposes,Cele,
+Customer Feedback,Informacja zwrotna Klienta,
+Maintenance Visit Purpose,Cel Wizyty Konserwacji,
+Work Done,Praca wykonana,
+MFG-BLR-.YYYY.-,MFG-BLR-.RRRR.-,
+Order Type,Typ zamówienia,
+Blanket Order Item,Koc Zamówienie przedmiotu,
+Ordered Quantity,Zamówiona Ilość,
+Item to be manufactured or repacked,"Produkt, który ma zostać wyprodukowany lub przepakowany",
+Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Ilość produktu otrzymanego po produkcji / przepakowaniu z podanych ilości surowców,
+Set rate of sub-assembly item based on BOM,Ustaw stawkę pozycji podzakresu na podstawie BOM,
+Allow Alternative Item,Zezwalaj na alternatywną pozycję,
+Item UOM,Jednostka miary produktu,
+Conversion Rate,Współczynnik konwersji,
+Rate Of Materials Based On,Stawka Materiałów Wzorowana na,
+With Operations,Wraz z działaniami,
+Manage cost of operations,Zarządzaj kosztami działań,
+Transfer Material Against,Materiał transferowy przeciwko,
+Routing,Routing,
+Materials,Materiały,
+Quality Inspection Required,Wymagana kontrola jakości,
+Quality Inspection Template,Szablon kontroli jakości,
+Scrap,Skrawek,
+Scrap Items,złom przedmioty,
+Operating Cost,Koszty Operacyjne,
+Raw Material Cost,Koszt surowców,
+Scrap Material Cost,Złom Materiał Koszt,
+Operating Cost (Company Currency),Koszty operacyjne (Spółka waluty),
+Raw Material Cost (Company Currency),Koszt surowców (waluta spółki),
+Scrap Material Cost(Company Currency),Złom koszt materiału (Spółka waluty),
+Total Cost,Koszt całkowity,
+Total Cost (Company Currency),Koszt całkowity (waluta firmy),
+Materials Required (Exploded),Materiał Wymaga (Rozdzielony),
+Exploded Items,Przedmioty wybuchowe,
+Show in Website,Pokaż w witrynie,
+Item Image (if not slideshow),Element Obrazek (jeśli nie slideshow),
+Thumbnail,Miniaturka,
+Website Specifications,Specyfikacja strony WWW,
+Show Items,jasnowidze,
+Show Operations,Pokaż Operations,
+Website Description,Opis strony WWW,
+Qty Consumed Per Unit,Ilość skonsumowana na Jednostkę,
+Include Item In Manufacturing,Dołącz przedmiot do produkcji,
+Item operation,Obsługa przedmiotu,
+Rate & Amount,Stawka i kwota,
+Basic Rate (Company Currency),Podstawowy wskaźnik (Waluta Firmy),
+Original Item,Oryginalna pozycja,
+BOM Operation,BOM Operacja,
+Operation Time ,Czas operacji,
+In minutes,W minutach,
+Batch Size,Wielkość partii,
+Base Hour Rate(Company Currency),Baza Hour Rate (Spółka waluty),
+Operating Cost(Company Currency),Koszty operacyjne (Spółka waluty),
+BOM Scrap Item,BOM Złom Item,
+Basic Amount (Company Currency),Kwota podstawowa (Spółka waluty),
+BOM Update Tool,Narzędzie aktualizacji BOM,
+"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.\nIt also updates latest price in all the BOMs.","Zastąp wymień płytę BOM we wszystkich pozostałych zestawieniach, w których jest używany. Zastąpi stary link BOM, aktualizuje koszt i zregeneruje tabelę &quot;BOM Explosion Item&quot; w nowym zestawieniu firm. Uaktualnia także najnowszą cenę we wszystkich materiałach.",
+Replace BOM,Wymień moduł,
+Current BOM,Obecny BOM,
+The BOM which will be replaced,BOM zostanie zastąpiony,
+The new BOM after replacement,Nowy BOM po wymianie,
+Replace,Zamień,
+Update latest price in all BOMs,Zaktualizuj ostatnią cenę we wszystkich biuletynach,
+BOM Website Item,BOM Website Element,
+BOM Website Operation,BOM Operacja WWW,
+Operation Time,Czas operacji,
+PO-JOB.#####,PO-JOB. #####,
+Timing Detail,Szczegóły dotyczące czasu,
+Time Logs,Logi czasu,
+Total Time in Mins,Całkowity czas w minutach,
+Operation ID,Identyfikator operacji,
+Transferred Qty,Przeniesione ilości,
+Job Started,Rozpoczęto pracę,
+Started Time,Rozpoczęty czas,
+Current Time,Obecny czas,
+Job Card Item,Element karty pracy,
+Job Card Time Log,Dziennik czasu pracy karty,
+Time In Mins,Czas w minutach,
+Completed Qty,Ukończona wartość,
+Manufacturing Settings,Ustawienia produkcyjne,
+Raw Materials Consumption,Zużycie surowców,
+Allow Multiple Material Consumption,Zezwalaj na wielokrotne zużycie materiałów,
+Backflush Raw Materials Based On,Płukanie surowce na podstawie,
+Material Transferred for Manufacture,Materiał Przeniesiony do Produkcji,
+Capacity Planning,Planowanie Pojemności,
+Disable Capacity Planning,Wyłącz planowanie wydajności,
+Allow Overtime,Pozwól na Nadgodziny,
+Allow Production on Holidays,Pozwól Produkcja na święta,
+Capacity Planning For (Days),Planowanie Pojemności Dla (dni),
+Default Warehouses for Production,Domyślne magazyny do produkcji,
+Default Work In Progress Warehouse,Domyślnie Work In Progress Warehouse,
+Default Finished Goods Warehouse,Magazyn wyrobów gotowych domyślne,
+Default Scrap Warehouse,Domyślny magazyn złomu,
+Overproduction Percentage For Sales Order,Procent nadprodukcji dla zamówienia sprzedaży,
+Overproduction Percentage For Work Order,Nadwyżka produkcyjna Procent zamówienia na pracę,
+Other Settings,Inne ustawienia,
+Update BOM Cost Automatically,Zaktualizuj automatycznie koszt BOM,
+Material Request Plan Item,Material Request Plan Item,
+Material Request Type,Typ zamówienia produktu,
+Material Issue,Wydanie materiałów,
+Customer Provided,Dostarczony Klient,
+Minimum Order Quantity,Minimalna ilość zamówienia,
+Default Workstation,Domyślne miejsce pracy,
+Production Plan,Plan produkcji,
+MFG-PP-.YYYY.-,MFG-PP-.RRRR.-,
+Get Items From,Pobierz zawartość z,
+Get Sales Orders,Pobierz zamówienia sprzedaży,
+Material Request Detail,Szczegółowy wniosek o materiał,
+Get Material Request,Uzyskaj Materiał Zamówienie,
+Material Requests,materiał Wnioski,
+Get Items For Work Order,Zdobądź przedmioty na zlecenie pracy,
+Material Request Planning,Planowanie zapotrzebowania materiałowego,
+Include Non Stock Items,Uwzględnij pozycje niepubliczne,
+Include Subcontracted Items,Uwzględnij elementy podwykonawstwa,
+Ignore Existing Projected Quantity,Ignoruj istniejącą przewidywaną ilość,
+"To know more about projected quantity, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">click here</a>.","Aby dowiedzieć się więcej o przewidywanej ilości, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">kliknij tutaj</a> .",
+Download Required Materials,Pobierz wymagane materiały,
+Get Raw Materials For Production,Zdobądź surowce do produkcji,
+Total Planned Qty,Całkowita planowana ilość,
+Total Produced Qty,Całkowita ilość wyprodukowanej,
+Material Requested,Żądany materiał,
+Production Plan Item,Przedmiot planu produkcji,
+Make Work Order for Sub Assembly Items,Wykonaj zlecenie pracy dla elementów podzespołu,
+"If enabled, system will create the work order for the exploded items against which BOM is available.","Jeśli ta opcja jest włączona, system utworzy zlecenie pracy dla rozstrzelonych elementów, dla których dostępna jest LM.",
+Planned Start Date,Planowana data rozpoczęcia,
+Quantity and Description,Ilość i opis,
+material_request_item,material_request_item,
+Product Bundle Item,Pakiet produktów Artykuł,
+Production Plan Material Request,Produkcja Plan Materiał Zapytanie,
+Production Plan Sales Order,Zamówienie sprzedaży plany produkcji,
+Sales Order Date,Data Zlecenia,
+Routing Name,Nazwa trasy,
+MFG-WO-.YYYY.-,MFG-WO-.RRRR.-,
+Item To Manufacture,Rzecz do wyprodukowania,
+Material Transferred for Manufacturing,Materiał Przeniesiony do Produkowania,
+Manufactured Qty,Ilość wyprodukowanych,
+Use Multi-Level BOM,Używaj wielopoziomowych zestawień materiałowych,
+Plan material for sub-assemblies,Materiał plan podzespołów,
+Skip Material Transfer to WIP Warehouse,Pomiń transfer materiałów do magazynu WIP,
+Check if material transfer entry is not required,"Sprawdź, czy nie ma konieczności wczytywania materiału",
+Backflush Raw Materials From Work-in-Progress Warehouse,Surowiec do płukania zwrotnego z magazynu w toku,
+Update Consumed Material Cost In Project,Zaktualizuj zużyty koszt materiałowy w projekcie,
+Warehouses,Magazyny,
+This is a location where raw materials are available.,"Jest to miejsce, w którym dostępne są surowce.",
+Work-in-Progress Warehouse,Magazyn z produkcją w toku,
+This is a location where operations are executed.,"Jest to miejsce, w którym wykonywane są operacje.",
+This is a location where final product stored.,"Jest to miejsce, w którym przechowywany jest produkt końcowy.",
+Scrap Warehouse,złom Magazyn,
+This is a location where scraped materials are stored.,"Jest to miejsce, w którym przechowywane są zeskrobane materiały.",
+Required Items,wymagane przedmioty,
+Actual Start Date,Rzeczywista data rozpoczęcia,
+Planned End Date,Planowana data zakończenia,
+Actual End Date,Rzeczywista Data Zakończenia,
+Operation Cost,Koszt operacji,
+Planned Operating Cost,Planowany koszt operacyjny,
+Actual Operating Cost,Rzeczywisty koszt operacyjny,
+Additional Operating Cost,Dodatkowy koszt operacyjny,
+Total Operating Cost,Całkowity koszt operacyjny,
+Manufacture against Material Request,Wytwarzanie przeciwko Materiały Zamówienie,
+Work Order Item,Pozycja zlecenia pracy,
+Available Qty at Source Warehouse,Dostępne ilości w magazynie źródłowym,
+Available Qty at WIP Warehouse,Dostępne ilości w magazynie WIP,
+Work Order Operation,Działanie zlecenia pracy,
+Operation Description,Opis operacji,
+Operation completed for how many finished goods?,Operacja zakończona na jak wiele wyrobów gotowych?,
+Work in Progress,Produkty w toku,
+Estimated Time and Cost,Szacowany czas i koszt,
+Planned Start Time,Planowany czas rozpoczęcia,
+Planned End Time,Planowany czas zakończenia,
+in Minutes,W ciągu kilku minut,
+Actual Time and Cost,Rzeczywisty Czas i Koszt,
+Actual Start Time,Rzeczywisty Czas Rozpoczęcia,
+Actual End Time,Rzeczywisty czas zakończenia,
+Updated via 'Time Log',"Aktualizowana przez ""Czas Zaloguj""",
+Actual Operation Time,Rzeczywisty Czas pracy,
+in Minutes\nUpdated via 'Time Log',"w minutach \n Aktualizacja poprzez ""Czas Zaloguj""",
+(Hour Rate / 60) * Actual Operation Time,(Godzina Kursy / 60) * Rzeczywista Czas pracy,
+Workstation Name,Nazwa stacji roboczej,
+Production Capacity,Moce produkcyjne,
+Operating Costs,Koszty operacyjne,
+Electricity Cost,Koszt energii elekrycznej,
+per hour,na godzinę,
+Consumable Cost,Koszt Konsumpcyjny,
+Rent Cost,Koszt Wynajmu,
+Wages,Zarobki,
+Wages per hour,Zarobki na godzinę,
+Net Hour Rate,Stawka godzinowa Netto,
+Workstation Working Hour,Godziny robocze Stacji Roboczej,
+Certification Application,Aplikacja certyfikacyjna,
+Name of Applicant,Nazwa wnioskodawcy,
+Certification Status,Status certyfikacji,
+Yet to appear,Jeszcze się pojawi,
+Certified,Atestowany,
+Not Certified,Brak certyfikatu,
+USD,USD,
+INR,INR,
+Certified Consultant,Certyfikowany konsultant,
+Name of Consultant,Imię i nazwisko konsultanta,
+Certification Validity,Ważność certyfikacji,
+Discuss ID,Omów ID,
+GitHub ID,Identyfikator GitHub,
+Non Profit Manager,Non Profit Manager,
+Chapter Head,Rozdział Głowy,
+Meetup Embed HTML,Meetup Osadź HTML,
+chapters/chapter_name\nleave blank automatically set after saving chapter.,rozdziały / chapter_name pozostaw puste puste automatycznie ustawione po zapisaniu rozdziału.,
+Chapter Members,Członkowie rozdziału,
+Members,Członkowie,
+Chapter Member,Członek rozdziału,
+Website URL,URL strony WWW,
+Leave Reason,Powód Nieobecności,
+Donor Name,Nazwa dawcy,
+Donor Type,Rodzaj dawcy,
+Withdrawn,Zamknięty w sobie,
+Grant Application Details ,Przyznaj szczegóły aplikacji,
+Grant Description,Opis dotacji,
+Requested Amount,Wnioskowana kwota,
+Has any past Grant Record,Ma jakąkolwiek przeszłość Grant Record,
+Show on Website,Pokaż na stronie internetowej,
+Assessment  Mark (Out of 10),Ocena (na 10),
+Assessment  Manager,Menedżer oceny,
+Email Notification Sent,Wysłane powiadomienie e-mail,
+NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-,
+Membership Expiry Date,Data wygaśnięcia członkostwa,
+Razorpay Details,Szczegóły Razorpay,
+Subscription ID,Identyfikator subskrypcji,
+Customer ID,Identyfikator klienta,
+Subscription Activated,Subskrypcja aktywowana,
+Subscription Start ,Rozpocznij subskrypcję,
+Subscription End,Koniec subskrypcji,
+Non Profit Member,Członek non profit,
+Membership Status,Status członkostwa,
+Member Since,Członek od,
+Payment ID,Identyfikator płatności,
+Membership Settings,Ustawienia członkostwa,
+Enable RazorPay For Memberships,Włącz RazorPay dla członkostwa,
+RazorPay Settings,Ustawienia RazorPay,
+Billing Cycle,Cykl rozliczeniowy,
+Billing Frequency,Częstotliwość rozliczeń,
+"The number of billing cycles for which the customer should be charged. For example, if a customer is buying a 1-year membership that should be billed on a monthly basis, this value should be 12.","Liczba cykli rozliczeniowych, za które klient powinien zostać obciążony. Na przykład, jeśli klient kupuje roczne członkostwo, które powinno być rozliczane co miesiąc, ta wartość powinna wynosić 12.",
+Razorpay Plan ID,Identyfikator planu Razorpay,
+Volunteer Name,Nazwisko wolontariusza,
+Volunteer Type,Typ wolontariusza,
+Availability and Skills,Dostępność i umiejętności,
+Availability,Dostępność,
+Weekends,Weekendy,
+Availability Timeslot,Dostępność Timeslot,
+Morning,Ranek,
+Afternoon,Popołudnie,
+Evening,Wieczór,
+Anytime,W każdej chwili,
+Volunteer Skills,Umiejętności ochotnicze,
+Volunteer Skill,Wolontariat,
+Homepage,Strona główna,
+Hero Section Based On,Sekcja bohatera na podstawie,
+Homepage Section,Sekcja strony głównej,
+Hero Section,Sekcja bohatera,
+Tag Line,Slogan reklamowy,
+Company Tagline for website homepage,Slogan reklamowy firmy na głównej stronie,
+Company Description for website homepage,Opis firmy na stronie głównej,
+Homepage Slideshow,Pokaz slajdów na stronie głównej,
+"URL for ""All Products""",URL do wszystkich produktów,
+Products to be shown on website homepage,Produkty przeznaczone do pokazania na głównej stronie,
+Homepage Featured Product,Ciekawa Strona produktu,
+route,trasa,
+Section Based On,Sekcja na podstawie,
+Section Cards,Karty sekcji,
+Number of Columns,Liczba kolumn,
+Number of columns for this section. 3 cards will be shown per row if you select 3 columns.,"Liczba kolumn dla tej sekcji. 3 wiersze zostaną wyświetlone w wierszu, jeśli wybierzesz 3 kolumny.",
+Section HTML,Sekcja HTML,
+Use this field to render any custom HTML in the section.,To pole służy do renderowania dowolnego niestandardowego kodu HTML w sekcji.,
+Section Order,Kolejność sekcji,
+"Order in which sections should appear. 0 is first, 1 is second and so on.","Kolejność, w której sekcje powinny się pojawić. 0 jest pierwsze, 1 jest drugie i tak dalej.",
+Homepage Section Card,Strona główna Karta sekcji,
+Subtitle,Podtytuł,
+Products Settings,produkty Ustawienia,
+Home Page is Products,Strona internetowa firmy jest produktem,
+"If checked, the Home page will be the default Item Group for the website","Jeśli zaznaczone, strona główna będzie Grupa domyślna pozycja na stronie",
+Show Availability Status,Pokaż status dostępności,
+Product Page,Strona produktu,
+Products per Page,Produkty na stronę,
+Enable Field Filters,Włącz filtry pola,
+Item Fields,Pola przedmiotów,
+Enable Attribute Filters,Włącz filtry atrybutów,
+Attributes,Atrybuty,
+Hide Variants,Ukryj warianty,
+Website Attribute,Atrybut strony,
+Attribute,Atrybut,
+Website Filter Field,Pole filtru witryny,
+Activity Cost,Aktywny Koszt,
+Billing Rate,Kursy rozliczeniowe,
+Costing Rate,Wskaźnik zestawienia kosztów,
+title,tytuł,
+Projects User,Użytkownik projektu,
+Default Costing Rate,Domyślnie Costing Cena,
+Default Billing Rate,Domyślnie Cena płatności,
+Dependent Task,Zadanie zależne,
+Project Type,Typ projektu,
+% Complete Method,Kompletna Metoda%,
+Task Completion,zadanie Zakończenie,
+Task Progress,Postęp wykonywania zadania,
+% Completed,% ukończone,
+From Template,Z szablonu,
+Project will be accessible on the website to these users,Projekt będzie dostępny na stronie internetowej dla tych użytkowników,
+Copied From,Skopiowano z,
+Start and End Dates,Daty rozpoczęcia i zakończenia,
+Actual Time (in Hours),Rzeczywisty czas (w godzinach),
+Costing and Billing,Kalkulacja kosztów i fakturowanie,
+Total Costing Amount (via Timesheets),Łączna kwota kosztów (za pośrednictwem kart pracy),
+Total Expense Claim (via Expense Claims),Łączny koszt roszczenie (przez zwrot kosztów),
+Total Purchase Cost (via Purchase Invoice),Całkowity koszt zakupu (faktura zakupu za pośrednictwem),
+Total Sales Amount (via Sales Order),Całkowita kwota sprzedaży (poprzez zamówienie sprzedaży),
+Total Billable Amount (via Timesheets),Całkowita kwota do naliczenia (za pośrednictwem kart pracy),
+Total Billed Amount (via Sales Invoices),Całkowita kwota faktury (za pośrednictwem faktur sprzedaży),
+Total Consumed Material Cost  (via Stock Entry),Całkowity koszt materiałów konsumpcyjnych (poprzez wprowadzenie do magazynu),
+Gross Margin,Marża brutto,
+Gross Margin %,Marża brutto %,
+Monitor Progress,Monitorowanie postępu,
+Collect Progress,Zbierz postęp,
+Frequency To Collect Progress,Częstotliwość zbierania postępów,
+Twice Daily,Dwa razy dziennie,
+First Email,Pierwszy e-mail,
+Second Email,Drugi e-mail,
+Time to send,Czas wysłać,
+Day to Send,Dzień na wysłanie,
+Message will be sent to the users to get their status on the Project,Wiadomość zostanie wysłana do użytkowników w celu uzyskania ich statusu w Projekcie,
+Projects Manager,Kierownik Projektów,
+Project Template,Szablon projektu,
+Project Template Task,Zadanie szablonu projektu,
+Begin On (Days),Rozpocznij od (dni),
+Duration (Days),Czas trwania (dni),
+Project Update,Aktualizacja projektu,
+Project User,Użytkownik projektu,
+View attachments,Wyświetl załączniki,
+Projects Settings,Ustawienia projektów,
+Ignore Workstation Time Overlap,Zignoruj nakładanie się czasu w stacji roboczej,
+Ignore User Time Overlap,Zignoruj nakładanie się czasu użytkownika,
+Ignore Employee Time Overlap,Zignoruj nakładanie się czasu pracownika,
+Weight,Waga,
+Parent Task,Zadanie rodzica,
+Timeline,Oś czasu,
+Expected Time (in hours),Oczekiwany czas (w godzinach),
+% Progress,% Postęp,
+Is Milestone,Jest Milestone,
+Task Description,Opis zadania,
+Dependencies,Zależności,
+Dependent Tasks,Zadania zależne,
+Depends on Tasks,Zależy Zadania,
+Actual Start Date (via Time Sheet),Faktyczna data rozpoczęcia (przez czas arkuszu),
+Actual Time (in hours),Rzeczywisty czas (w godzinach),
+Actual End Date (via Time Sheet),Faktyczna data zakończenia (przez czas arkuszu),
+Total Costing Amount (via Time Sheet),Całkowita kwota Costing (przez czas arkuszu),
+Total Expense Claim (via Expense Claim),Razem zwrot kosztów (przez zwrot kosztów),
+Total Billing Amount (via Time Sheet),Całkowita kwota płatności (poprzez Czas Sheet),
+Review Date,Data Przeglądu,
+Closing Date,Data zamknięcia,
+Task Depends On,Zadanie zależne od,
+Task Type,Typ zadania,
+TS-.YYYY.-,TS-.YYYY.-,
+Employee Detail,Szczegóły urzędnik,
+Billing Details,Szczegóły płatności,
+Total Billable Hours,Całkowita liczba godzin rozliczanych,
+Total Billed Hours,Wszystkich Zafakturowane Godziny,
+Total Costing Amount,Łączna kwota Costing,
+Total Billable Amount,Całkowita kwota podlegająca rozliczeniom,
+Total Billed Amount,Kwota całkowita Zapowiadane,
+% Amount Billed,% wartości rozliczonej,
+Hrs,godziny,
+Costing Amount,Kwota zestawienia kosztów,
+Corrective/Preventive,Korygujące / zapobiegawcze,
+Corrective,Poprawczy,
+Preventive,Zapobiegawczy,
+Resolution,Rozstrzygnięcie,
+Resolutions,Postanowienia,
+Quality Action Resolution,Rezolucja dotycząca jakości działania,
+Quality Feedback Parameter,Parametr sprzężenia zwrotnego jakości,
+Quality Feedback Template Parameter,Parametr szablonu opinii o jakości,
+Quality Goal,Cel jakości,
+Monitoring Frequency,Monitorowanie częstotliwości,
+Weekday,Dzień powszedni,
+Objectives,Cele,
+Quality Goal Objective,Cel celu jakości,
+Objective,Cel,
+Agenda,Program,
+Minutes,Minuty,
+Quality Meeting Agenda,Agenda spotkania jakości,
+Quality Meeting Minutes,Protokół spotkania jakości,
+Minute,Minuta,
+Parent Procedure,Procedura rodzicielska,
+Processes,Procesy,
+Quality Procedure Process,Proces procedury jakości,
+Process Description,Opis procesu,
+Link existing Quality Procedure.,Połącz istniejącą procedurę jakości.,
+Additional Information,Dodatkowe informacje,
+Quality Review Objective,Cel przeglądu jakości,
+DATEV Settings,Ustawienia DATEV,
+Regional,Regionalny,
+Consultant ID,ID konsultanta,
+GST HSN Code,Kod GST HSN,
+HSN Code,Kod HSN,
+GST Settings,Ustawienia GST,
+GST Summary,Podsumowanie GST,
+GSTIN Email Sent On,Wysłano pocztę GSTIN,
+GST Accounts,Konta GST,
+B2C Limit,Limit B2C,
+Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Ustaw wartość faktury dla B2C. B2CL i B2CS obliczane na podstawie tej wartości faktury.,
+GSTR 3B Report,Raport GSTR 3B,
+January,styczeń,
+February,luty,
+March,Marsz,
+April,kwiecień,
+May,Maj,
+June,czerwiec,
+July,lipiec,
+August,sierpień,
+September,wrzesień,
+October,październik,
+November,listopad,
+December,grudzień,
+JSON Output,Wyjście JSON,
+Invoices with no Place Of Supply,Faktury bez miejsca dostawy,
+Import Supplier Invoice,Importuj fakturę od dostawcy,
+Invoice Series,Seria faktur,
+Upload XML Invoices,Prześlij faktury XML,
+Zip File,Plik zip,
+Import Invoices,Importuj faktury,
+Click on Import Invoices button once the zip file has been attached to the document. Any errors related to processing will be shown in the Error Log.,Kliknij przycisk Importuj faktury po dołączeniu pliku zip do dokumentu. Wszelkie błędy związane z przetwarzaniem zostaną wyświetlone w dzienniku błędów.,
+Lower Deduction Certificate,Certyfikat niższego potrącenia,
+Certificate Details,Szczegóły certyfikatu,
+194A,194A,
+194C,194C,
+194D,194D,
+194H,194H,
+194I,194I,
+194J,194J,
+194LA,194LA,
+194LBB,194LBB,
+194LBC,194LBC,
+Certificate No,Certyfikat nr,
+Deductee Details,Szczegóły dotyczące odliczonego,
+PAN No,Nr PAN,
+Validity Details,Szczegóły dotyczące ważności,
+Rate Of TDS As Per Certificate,Stawka TDS zgodnie z certyfikatem,
+Certificate Limit,Limit certyfikatu,
+Invoice Series Prefix,Prefiks serii faktur,
+Active Menu,Aktywne menu,
+Restaurant Menu,Menu restauracji,
+Price List (Auto created),Cennik (utworzony automatycznie),
+Restaurant Manager,Menadżer restauracji,
+Restaurant Menu Item,Menu restauracji,
+Restaurant Order Entry,Wprowadzanie do restauracji,
+Restaurant Table,Stolik Restauracyjny,
+Click Enter To Add,Kliknij Enter To Add,
+Last Sales Invoice,Ostatnia sprzedaż faktury,
+Current Order,Aktualne zamówienie,
+Restaurant Order Entry Item,Restauracja Order Entry Pozycja,
+Served,Serwowane,
+Restaurant Reservation,Rezerwacja restauracji,
+Waitlisted,Na liście Oczekujących,
+No Show,Brak pokazu,
+No of People,Liczba osób,
+Reservation Time,Czas rezerwacji,
+Reservation End Time,Rezerwacja Koniec czasu,
+No of Seats,Liczba miejsc,
+Minimum Seating,Minimalne miejsce siedzące,
+"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment. ","Śledź kampanię sprzedażową. Śledź Tropy, Wyceny, Zamówienia Sprzedaży etc. z kampanii by zmierzyć zwrot z inwestycji.",
+SAL-CAM-.YYYY.-,SAL-CAM-.YYYY.-,
+Campaign Schedules,Harmonogramy kampanii,
+Buyer of Goods and Services.,Nabywca Towarów i Usług.,
+CUST-.YYYY.-,CUST-.YYYY.-.-,
+Default Company Bank Account,Domyślne firmowe konto bankowe,
+From Lead,Od śladu,
+Account Manager,Menadżer konta,
+Allow Sales Invoice Creation Without Sales Order,Zezwalaj na tworzenie faktur sprzedaży bez zamówienia sprzedaży,
+Allow Sales Invoice Creation Without Delivery Note,Zezwalaj na tworzenie faktur sprzedaży bez potwierdzenia dostawy,
+Default Price List,Domyślny cennik,
+Primary Address and Contact Detail,Główny adres i dane kontaktowe,
+"Select, to make the customer searchable with these fields","Wybierz, aby klient mógł wyszukać za pomocą tych pól",
+Customer Primary Contact,Kontakt główny klienta,
+"Reselect, if the chosen contact is edited after save","Ponownie wybierz, jeśli wybrany kontakt jest edytowany po zapisaniu",
+Customer Primary Address,Główny adres klienta,
+"Reselect, if the chosen address is edited after save","Ponownie wybierz, jeśli wybrany adres jest edytowany po zapisaniu",
+Primary Address,adres główny,
+Mention if non-standard receivable account,"Wskazać, jeśli niestandardowe konto należności",
+Credit Limit and Payment Terms,Limit kredytowy i warunki płatności,
+Additional information regarding the customer.,Dodatkowe informacje na temat klienta.,
+Sales Partner and Commission,Partner sprzedaży i Prowizja,
+Commission Rate,Wartość prowizji,
+Sales Team Details,Szczegóły dotyczące Teamu Sprzedażowego,
+Customer POS id,Identyfikator punktu sprzedaży klienta,
+Customer Credit Limit,Limit kredytu klienta,
+Bypass Credit Limit Check at Sales Order,Pomiń limit kredytowy w zleceniu klienta,
+Industry Type,Typ Przedsiębiorstwa,
+MAT-INS-.YYYY.-,MAT-INS-.YYYY.-,
+Installation Date,Data instalacji,
+Installation Time,Czas instalacji,
+Installed Qty,Liczba instalacji,
+Period Start Date,Data rozpoczęcia okresu,
+Period End Date,Data zakończenia okresu,
+Cashier,Kasjer,
+Difference,Różnica,
+Modes of Payment,Tryby płatności,
+Linked Invoices,Powiązane faktury,
+POS Closing Voucher Details,Szczegóły kuponu zamykającego POS,
+Collected Amount,Zebrana kwota,
+Expected Amount,Oczekiwana kwota,
+POS Closing Voucher Invoices,Faktury z zamknięciem kuponu,
+Quantity of Items,Ilość przedmiotów,
+"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. \n\nThe package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".\n\nFor Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.\n\nNote: BOM = Bill of Materials","Łączna grupa przedmioty ** ** ** Przedmiot do innego **. Jest to przydatne, jeśli łączenie pewnej ** przedmioty ** w pakiet i utrzymania zapasów pakowanych ** rzeczy ** a nie sumę ** rzecz **. Pakiet ** Pozycja ** będzie miał ""Czy Pozycja Zdjęcie"", jak ""Nie"" i ""Czy Sales Item"", jak ""Tak"". Dla przykładu: Jeśli sprzedajesz Laptopy i plecaki oddzielnie i mają specjalną cenę, jeśli klient kupuje oba, a następnie Laptop + Plecak będzie nowy Bundle wyrobów poz. Uwaga: ZM = Zestawienie Materiałów",
+Parent Item,Element nadrzędny,
+List items that form the package.,Lista elementów w pakiecie,
+SAL-QTN-.YYYY.-,SAL-QTN-.RRRR.-,
+Quotation To,Wycena dla,
+Rate at which customer's currency is converted to company's base currency,Stawka przy użyciu której Waluta Klienta jest konwertowana do podstawowej waluty firmy,
+Rate at which Price list currency is converted to company's base currency,Stawka przy użyciu której waluta Listy Cen jest konwertowana do podstawowej waluty firmy,
+Additional Discount and Coupon Code,Dodatkowy kod rabatowy i kuponowy,
+Referral Sales Partner,Polecony partner handlowy,
+Term Details,Szczegóły warunków,
+Quotation Item,Przedmiot oferty,
+Additional Notes,Dodatkowe uwagi,
+SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-,
+Skip Delivery Note,Pomiń dowód dostawy,
+In Words will be visible once you save the Sales Order.,"Słownie, będzie widoczne w Zamówieniu Sprzedaży, po zapisaniu",
+Track this Sales Order against any Project,Śledź zamówienie sprzedaży w każdym projekcie,
+Billing and Delivery Status,Fakturowanie i status dostawy,
+Not Delivered,Nie dostarczony,
+Fully Delivered,Całkowicie dostarczono,
+Partly Delivered,Częściowo Dostarczono,
+Not Applicable,Nie dotyczy,
+%  Delivered,% dostarczono,
+% of materials delivered against this Sales Order,% materiałów dostarczonych w ramach zlecenia sprzedaży,
+% of materials billed against this Sales Order,% materiałów rozliczonych w ramach tego zlecenia sprzedaży,
+Not Billed,Nie zaksięgowany,
+Fully Billed,Całkowicie Rozliczone,
+Partly Billed,Częściowo Zapłacono,
+Ensure Delivery Based on Produced Serial No,Zapewnij dostawę na podstawie wyprodukowanego numeru seryjnego,
+Supplier delivers to Customer,Dostawca dostarcza Klientowi,
+Delivery Warehouse,Magazyn Dostawa,
+Planned Quantity,Planowana ilość,
+For Production,Dla Produkcji,
+Work Order Qty,Ilość zlecenia pracy,
+Produced Quantity,Wyprodukowana ilość,
+Used for Production Plan,Używane do Planu Produkcji,
+Sales Partner Type,Typ partnera handlowego,
+Contact No.,Numer Kontaktu,
+Contribution (%),Udział (%),
+Selling Settings,Ustawienia sprzedaży,
+Settings for Selling Module,Ustawienia modułu sprzedaży,
+Campaign Naming By,Konwencja nazewnictwa Kampanii przez,
+Default Customer Group,Domyślna grupa klientów,
+Default Territory,Domyślne terytorium,
+Close Opportunity After Days,Po blisko Szansa Dni,
+Default Quotation Validity Days,Domyślna ważność oferty,
+Sales Update Frequency,Częstotliwość aktualizacji sprzedaży,
+Each Transaction,Każda transakcja,
+SMS Center,Centrum SMS,
+Send To,Wyślij do,
+All Contact,Wszystkie dane Kontaktu,
+All Customer Contact,Wszystkie dane kontaktowe klienta,
+All Supplier Contact,Dane wszystkich dostawców,
+All Sales Partner Contact,Wszystkie dane kontaktowe Partnera Sprzedaży,
+All Lead (Open),Wszystkie Leady (Otwarte),
+All Employee (Active),Wszyscy pracownicy (aktywni),
+All Sales Person,Wszyscy Sprzedawcy,
+Create Receiver List,Stwórz listę odbiorców,
+Receiver List,Lista odbiorców,
+Messages greater than 160 characters will be split into multiple messages,Wiadomości dłuższe niż 160 znaków zostaną podzielone na kilka wiadomości,
+Total Characters,Wszystkich Postacie,
+Total Message(s),Razem ilość wiadomości,
+Authorization Control,Kontrola Autoryzacji,
+Authorization Rule,Reguła autoryzacji,
+Average Discount,Średni Rabat,
+Customerwise Discount,Zniżka dla klienta,
+Itemwise Discount,Pozycja Rabat automatyczny,
+Customer or Item,Klient lub przedmiotu,
+Customer / Item Name,Klient / Nazwa Przedmiotu,
+Authorized Value,Autoryzowany Wartość,
+Applicable To (Role),Stosowne dla (Rola),
+Applicable To (Employee),Stosowne dla (Pracownik),
+Applicable To (User),Stosowne dla (Użytkownik),
+Applicable To (Designation),Stosowne dla (Nominacja),
+Approving Role (above authorized value),Zatwierdzanie rolę (powyżej dopuszczonego wartości),
+Approving User  (above authorized value),Zatwierdzanie autoryzowanego użytkownika (powyżej wartości),
+Brand Defaults,Domyślne marki,
+Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Osobowość prawna / Filia w oddzielny planu kont należących do Organizacji.,
+Change Abbreviation,Zmień Skrót,
+Parent Company,Przedsiębiorstwo macierzyste,
+Default Values,Domyślne wartości,
+Default Holiday List,Domyślna lista urlopowa,
+Default Selling Terms,Domyślne warunki sprzedaży,
+Default Buying Terms,Domyślne warunki zakupu,
+Create Chart Of Accounts Based On,Tworzenie planu kont w oparciu o,
+Standard Template,Szablon Standardowy,
+Existing Company,Istniejąca firma,
+Chart Of Accounts Template,Szablon planu kont,
+Existing Company ,istniejące firmy,
+Date of Establishment,Data założenia,
+Sales Settings,Ustawienia sprzedaży,
+Monthly Sales Target,Miesięczny cel sprzedaży,
+Sales Monthly History,Historia miesięczna sprzedaży,
+Transactions Annual History,Historia transakcji,
+Total Monthly Sales,Łączna miesięczna sprzedaż,
+Default Cash Account,Domyślne Konto Gotówkowe,
+Default Receivable Account,Domyślnie konto Rozrachunki z odbiorcami,
+Round Off Cost Center,Zaokrąglenia - Centrum Kosztów,
+Discount Allowed Account,Konto Dozwolone,
+Discount Received Account,Konto otrzymane z rabatem,
+Exchange Gain / Loss Account,Wymiana Zysk / strat,
+Unrealized Exchange Gain/Loss Account,Niezrealizowane konto zysku / straty z wymiany,
+Allow Account Creation Against Child Company,Zezwól na tworzenie konta przeciwko firmie podrzędnej,
+Default Payable Account,Domyślne konto Rozrachunki z dostawcami,
+Default Employee Advance Account,Domyślne konto Advance pracownika,
+Default Cost of Goods Sold Account,Domyślne Konto Wartości Dóbr Sprzedanych,
+Default Income Account,Domyślne konto przychodów,
+Default Deferred Revenue Account,Domyślne konto odroczonego przychodu,
+Default Deferred Expense Account,Domyślne konto odroczonego kosztu,
+Default Payroll Payable Account,Domyślny Płace Płatne konta,
+Default Expense Claim Payable Account,Rachunek wymagalny zapłaty domyślnego kosztu,
+Stock Settings,Ustawienia magazynu,
+Enable Perpetual Inventory,Włącz wieczne zapasy,
+Default Inventory Account,Domyślne konto zasobów reklamowych,
+Stock Adjustment Account,Konto korekty,
+Fixed Asset Depreciation Settings,Ustawienia Amortyzacja środka trwałego,
+Series for Asset Depreciation Entry (Journal Entry),Seria dla pozycji amortyzacji aktywów (wpis w czasopiśmie),
+Gain/Loss Account on Asset Disposal,Konto Zysk / Strata na Aktywów pozbywaniu,
+Asset Depreciation Cost Center,Zaleta Centrum Amortyzacja kosztów,
+Budget Detail,Szczegóły Budżetu,
+Exception Budget Approver Role,Rola zatwierdzającego wyjątku dla budżetu,
+Company Info,Informacje o firmie,
+For reference only.,Wyłącznie w celach informacyjnych.,
+Company Logo,Logo firmy,
+Date of Incorporation,Data przyłączenia,
+Date of Commencement,Data rozpoczęcia,
+Phone No,Nr telefonu,
+Company Description,Opis Firmy,
+Registration Details,Szczegóły Rejestracji,
+Delete Company Transactions,Usuń Transakcje Spółki,
+Currency Exchange,Wymiana Walut,
+Specify Exchange Rate to convert one currency into another,Określ Kursy walut konwersji jednej waluty w drugą,
+From Currency,Od Waluty,
+To Currency,Do przewalutowania,
+For Buying,Do kupienia,
+For Selling,Do sprzedania,
+Customer Group Name,Nazwa Grupy Klientów,
+Parent Customer Group,Nadrzędna Grupa Klientów,
+Mention if non-standard receivable account applicable,"Wspomnieć, jeśli nie standardowe konto należności dotyczy",
+Credit Limits,Limity kredytowe,
+Email Digest,przetwarzanie emaila,
+Send regular summary reports via Email.,Wyślij regularne raporty podsumowujące poprzez e-mail.,
+Email Digest Settings,ustawienia przetwarzania maila,
+How frequently?,Jak często?,
+Next email will be sent on:,Kolejny e-mali zostanie wysłany w dniu:,
+Note: Email will not be sent to disabled users,Uwaga: E-mail nie zostanie wysłany do nieaktywnych użytkowników,
+Profit & Loss,Rachunek zysków i strat,
+New Income,Nowy dochodowy,
+New Expenses,Nowe wydatki,
+Annual Income,Roczny dochód,
+Annual Expenses,roczne koszty,
+Bank Balance,Saldo bankowe,
+Bank Credit Balance,Saldo kredytu bankowego,
+Receivables,Należności,
+Payables,Zobowiązania,
+Sales Orders to Bill,Zlecenia sprzedaży do rachunku,
+Purchase Orders to Bill,Zamówienia zakupu do rachunku,
+Sales Orders to Deliver,Zlecenia sprzedaży do realizacji,
+Purchase Orders to Receive,Zamówienia zakupu do odbioru,
+New Purchase Invoice,Nowa faktura zakupu,
+New Quotations,Nowa oferta,
+Open Quotations,Otwarte oferty,
+Open Issues,Otwarte kwestie,
+Open Projects,Otwarte projekty,
+Purchase Orders Items Overdue,Przedmioty zamówienia przeterminowane,
+Upcoming Calendar Events,Nadchodzące wydarzenia w kalendarzu,
+Open To Do,Otwórz do zrobienia,
+Add Quote,Dodaj Cytat,
+Global Defaults,Globalne wartości domyślne,
+Default Company,Domyślna Firma,
+Current Fiscal Year,Obecny rok fiskalny,
+Default Distance Unit,Domyślna jednostka odległości,
+Hide Currency Symbol,Ukryj symbol walutowy,
+Do not show any symbol like $ etc next to currencies.,"Nie pokazuj żadnych symboli przy walutach, takich jak $",
+"If disable, 'Rounded Total' field will not be visible in any transaction","Jeśli wyłączone, pozycja 'Końcowa zaokrąglona suma' nie będzie widoczna w żadnej transakcji",
+Disable In Words,Wyłącz w słowach,
+"If disable, 'In Words' field will not be visible in any transaction",Jeśli wyłączyć &quot;w słowach&quot; pole nie będzie widoczne w każdej transakcji,
+Item Classification,Pozycja Klasyfikacja,
+General Settings,Ustawienia ogólne,
+Item Group Name,Element Nazwa grupy,
+Parent Item Group,Grupa Elementu nadrzędnego,
+Item Group Defaults,Domyślne grupy artykułów,
+Item Tax,Podatek dla tej pozycji,
+Check this if you want to show in website,Zaznacz czy chcesz uwidocznić to na stronie WWW,
+Show this slideshow at the top of the page,Pokaż slideshow na górze strony,
+HTML / Banner that will show on the top of product list.,"HTML / Banner, który pokaże się na górze listy produktów.",
+Set prefix for numbering series on your transactions,Ustaw prefiks dla numeracji serii na swoich transakcji,
+Setup Series,Konfigurowanie serii,
+Select Transaction,Wybierz Transakcję,
+Help HTML,Pomoc HTML,
+Series List for this Transaction,Lista serii dla tej transakcji,
+User must always select,Użytkownik musi zawsze zaznaczyć,
+Update Series,Zaktualizuj Serię,
+Change the starting / current sequence number of an existing series.,Zmień początkowy / obecny numer seryjny istniejącej serii.,
+Prefix,Prefiks,
+Current Value,Bieżąca Wartość,
+This is the number of the last created transaction with this prefix,Jest to numer ostatniej transakcji utworzonego z tym prefiksem,
+Update Series Number,Zaktualizuj Numer Serii,
+Quotation Lost Reason,Utracony Powód Wyceny,
+A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,"Dystrybutor strona trzecia / handlowiec / prowizji agenta / partner / sprzedawcę, który sprzedaje produkty firm z tytułu prowizji.",
+Sales Partner Name,Imię Partnera Sprzedaży,
+Partner Type,Typ Partnera,
+Address & Contacts,Adresy i kontakty,
+Address Desc,Opis adresu,
+Contact Desc,Opis kontaktu,
+Sales Partner Target,Cel Partnera Sprzedaży,
+Targets,Cele,
+Show In Website,Pokaż na stronie internetowej,
+Referral Code,kod polecającego,
+To Track inbound purchase,Aby śledzić zakupy przychodzące,
+Logo,Logo,
+Partner website,Strona partnera,
+All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Wszystkie transakcje sprzedaży mogą być oznaczone przed wieloma ** Osoby sprzedaży **, dzięki czemu można ustawić i monitorować cele.",
+Name and Employee ID,Imię i Identyfikator Pracownika,
+Sales Person Name,Imię Sprzedawcy,
+Parent Sales Person,Nadrzędny Przedstawiciel Handlowy,
+Select company name first.,Wybierz najpierw nazwę firmy,
+Sales Person Targets,Cele Sprzedawcy,
+Supplier Group Name,Nazwa grupy dostawcy,
+Parent Supplier Group,Rodzicielska grupa dostawców,
+Target Detail,Szczegóły celu,
+Target Qty,Ilość docelowa,
+Target  Amount,Kwota docelowa,
+Target Distribution,Dystrybucja docelowa,
+"Standard Terms and Conditions that can be added to Sales and Purchases.\n\nExamples:\n\n1. Validity of the offer.\n1. Payment Terms (In Advance, On Credit, part advance etc).\n1. What is extra (or payable by the Customer).\n1. Safety / usage warning.\n1. Warranty if any.\n1. Returns Policy.\n1. Terms of shipping, if applicable.\n1. Ways of addressing disputes, indemnity, liability, etc.\n1. Address and Contact of your Company.","Standardowe Zasady i warunki, które mogą być dodawane do sprzedaży i zakupów.\n\n Przykłady: \n\n 1. Ważność oferty.\n 1. Warunki płatności (z góry, na kredyt, część zaliczki itp).\n 1. Co to jest ekstra (lub płatne przez Klienta).\n 1. Bezpieczeństwo / ostrzeżenie wykorzystanie.\n 1. Gwarancja jeśli w ogóle.\n 1. Zwraca Polityka.\n 1. Warunki wysyłki, jeśli dotyczy.\n 1. Sposobów rozwiązywania sporów, odszkodowania, odpowiedzialność itp \n 1. Adres i kontakt z Twojej firmy.",
+Applicable Modules,Odpowiednie moduły,
+Terms and Conditions Help,Warunki Pomoc,
+Classification of Customers by region,Klasyfikacja Klientów od regionu,
+Territory Name,Nazwa Regionu,
+Parent Territory,Nadrzędne terytorium,
+Territory Manager,Kierownik Regionalny,
+For reference,Dla referencji,
+Territory Targets,Cele Regionalne,
+UOM Name,Nazwa Jednostki Miary,
+Check this to disallow fractions. (for Nos),Zaznacz to by zakazać ułamków (dla liczby jednostek),
+Website Item Group,Grupa przedmiotów strony WWW,
+Cross Listing of Item in multiple groups,Krzyż Notowania pozycji w wielu grupach,
+Default settings for Shopping Cart,Domyślne ustawienia koszyku,
+Enable Shopping Cart,Włącz Koszyk,
+Show Public Attachments,Pokaż załączniki publiczne,
+Show Price,Pokaż cenę,
+Show Stock Availability,Pokaż dostępność zapasów,
+Show Contact Us Button,Pokaż przycisk Skontaktuj się z nami,
+Show Stock Quantity,Pokaż ilość zapasów,
+Show Apply Coupon Code,Pokaż zastosuj kod kuponu,
+Allow items not in stock to be added to cart,Zezwól na dodanie produktów niedostępnych w magazynie do koszyka,
+Prices will not be shown if Price List is not set,"Ceny nie będą wyświetlane, jeśli Cennik nie jest ustawiony",
+Quotation Series,Serie Wyeceny,
+Checkout Settings,Zamówienie Ustawienia,
+Enable Checkout,Włącz kasę,
+Payment Success Url,Płatność Sukces URL,
+After payment completion redirect user to selected page.,Po dokonaniu płatności przekierować użytkownika do wybranej strony.,
+Batch Details,Szczegóły partii,
+Batch ID,Identyfikator Partii,
+image,wizerunek,
+Parent Batch,Nadrzędna partia,
+Manufacturing Date,Data produkcji,
+Batch Quantity,Ilość partii,
+Batch UOM,UOM partii,
+Source Document Type,Typ dokumentu źródłowego,
+Source Document Name,Nazwa dokumentu źródłowego,
+Batch Description,Opis partii,
+Bin,Kosz,
+Reserved Quantity,Zarezerwowana ilość,
+Actual Quantity,Rzeczywista Ilość,
+Requested Quantity,Oczekiwana ilość,
+Reserved Qty for sub contract,Zarezerwowana ilość na podwykonawstwo,
+Moving Average Rate,Cena Średnia Ruchoma,
+FCFS Rate,Pierwsza rata,
+Customs Tariff Number,Numer taryfy celnej,
+Tariff Number,Numer taryfy,
+Delivery To,Dostawa do,
+MAT-DN-.YYYY.-,MAT-DN-.YYYY.-,
+Is Return,Czy Wróć,
+Issue Credit Note,Problem Uwaga kredytowa,
+Return Against Delivery Note,Powrót Przeciwko dostawy nocie,
+Customer's Purchase Order No,Numer Zamówienia Zakupu Klienta,
+Billing Address Name,Nazwa Adresu do Faktury,
+"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Jeśli utworzono standardowy szablon w podatku od sprzedaży i Prowizji szablonu, wybierz jedną i kliknij na przycisk poniżej.",
+Transporter Info,Informacje dotyczące przewoźnika,
+Driver Name,Imię kierowcy,
+Track this Delivery Note against any Project,Śledź potwierdzenie dostawy w każdym projekcie,
+Inter Company Reference,Referencje między firmami,
+Print Without Amount,Drukuj bez wartości,
+% Installed,% Zainstalowanych,
+% of materials delivered against this Delivery Note,% materiałów dostarczonych w stosunku do dowodu dostawy,
+Installation Status,Status instalacji,
+Excise Page Number,Akcyza numeru strony,
+Instructions,Instrukcje,
+From Warehouse,Z magazynu,
+Against Sales Order,Na podstawie zamówienia sprzedaży,
+Against Sales Order Item,Na podstawie pozycji zamówienia sprzedaży,
+Against Sales Invoice,Na podstawie faktury sprzedaży,
+Against Sales Invoice Item,Na podstawie pozycji faktury sprzedaży,
+Available Batch Qty at From Warehouse,Ilosc w serii dostępne z magazynu,
+Available Qty at From Warehouse,Dostępne szt co z magazynu,
+Delivery Settings,Ustawienia dostawy,
+Dispatch Settings,Ustawienia wysyłki,
+Dispatch Notification Template,Szablon powiadomienia o wysyłce,
+Dispatch Notification Attachment,Powiadomienie o wysyłce,
+Leave blank to use the standard Delivery Note format,"Pozostaw puste, aby używać standardowego formatu dokumentu dostawy",
+Send with Attachment,Wyślij z załącznikiem,
+Delay between Delivery Stops,Opóźnienie między przerwami w dostawie,
+Delivery Stop,Przystanek dostawy,
+Lock,Zamek,
+Visited,Odwiedzony,
+Order Information,Szczegóły zamówienia,
+Contact Information,Informacje kontaktowe,
+Email sent to,Email wysłany do,
+Dispatch Information,Informacje o wysyłce,
+Estimated Arrival,Szacowany przyjazd,
+MAT-DT-.YYYY.-,MAT-DT-.RRRR.-,
+Initial Email Notification Sent,Wstępne powiadomienie e-mail wysłane,
+Delivery Details,Szczegóły dostawy,
+Driver Email,Adres e-mail kierowcy,
+Driver Address,Adres kierowcy,
+Total Estimated Distance,Łączna przewidywana odległość,
+Distance UOM,Odległość UOM,
+Departure Time,Godzina odjazdu,
+Delivery Stops,Przerwy w dostawie,
+Calculate Estimated Arrival Times,Oblicz szacowany czas przyjazdu,
+Use Google Maps Direction API to calculate estimated arrival times,"Użyj interfejsu API Google Maps Direction, aby obliczyć szacowany czas przybycia",
+Optimize Route,Zoptymalizuj trasę,
+Use Google Maps Direction API to optimize route,"Użyj Google Maps Direction API, aby zoptymalizować trasę",
+In Transit,W tranzycie,
+Fulfillment User,Użytkownik spełniający wymagania,
+"A Product or a Service that is bought, sold or kept in stock.","Produkt lub usługa, która jest kupiona, sprzedana lub przechowywana w magazynie.",
+STO-ITEM-.YYYY.-,STO-ITEM-.RRRR.-,
+Variant Of,Wariant,
+"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Jeśli pozycja jest wariant innego elementu, a następnie opis, zdjęcia, ceny, podatki itp zostanie ustalony z szablonu, o ile nie określono wyraźnie",
+Is Item from Hub,Jest Przedmiot z Hubu,
+Default Unit of Measure,Domyślna jednostka miary,
+Maintain Stock,Utrzymanie Zapasów,
+Standard Selling Rate,Standardowy kurs sprzedaży,
+Auto Create Assets on Purchase,Automatycznie twórz zasoby przy zakupie,
+Asset Naming Series,Asset Naming Series,
+Over Delivery/Receipt Allowance (%),Over Delivery / Receipt Allowance (%),
+Barcodes,Kody kreskowe,
+Shelf Life In Days,Okres przydatności do spożycia w dniach,
+End of Life,Zakończenie okresu eksploatacji,
+Default Material Request Type,Domyślnie Materiał Typ żądania,
+Valuation Method,Metoda wyceny,
+FIFO,FIFO,
+Moving Average,Średnia Ruchoma,
+Warranty Period (in days),Okres gwarancji (w dniach),
+Auto re-order,Automatyczne ponowne zamówienie,
+Reorder level based on Warehouse,Zmiana kolejności w oparciu o poziom Magazynu,
+Will also apply for variants unless overrridden,"Również zostanie zastosowany do wariantów, chyba że zostanie nadpisany",
+Units of Measure,Jednostki miary,
+Will also apply for variants,Również zastosowanie do wariantów,
+Serial Nos and Batches,Numery seryjne i partie,
+Has Batch No,Posada numer partii (batch),
+Automatically Create New Batch,Automatyczne tworzenie nowych partii,
+Batch Number Series,Seria numerów partii,
+"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.","Przykład: ABCD. #####. Jeśli seria jest ustawiona, a numer partii nie jest wymieniony w transakcjach, na podstawie tej serii zostanie utworzony automatyczny numer partii. Jeśli zawsze chcesz wyraźnie podać numer partii dla tego produktu, pozostaw to pole puste. Uwaga: to ustawienie ma pierwszeństwo przed prefiksem serii nazw w Ustawieniach fotografii.",
+Has Expiry Date,Ma datę wygaśnięcia,
+Retain Sample,Zachowaj próbkę,
+Max Sample Quantity,Maksymalna ilość próbki,
+Maximum sample quantity that can be retained,"Maksymalna ilość próbki, którą można zatrzymać",
+Has Serial No,Posiada numer seryjny,
+Serial Number Series,Seria nr seryjnego,
+"Example: ABCD.#####\nIf series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Przykład:. ABCD ##### \n Jeśli seria jest ustawiona i nr seryjny nie jest wymieniony w transakcjach, automatyczny numer seryjny zostanie utworzony na podstawie tej serii. Jeśli chcesz zawsze jednoznacznie ustawiać numery seryjne dla tej pozycji, pozostaw to pole puste.",
+Variants,Warianty,
+Has Variants,Ma Warianty,
+"If this item has variants, then it cannot be selected in sales orders etc.","Jeśli ten element ma warianty, to nie może być wybrany w zleceniach sprzedaży itp",
+Variant Based On,Wariant na podstawie,
+Item Attribute,Atrybut elementu,
+"Sales, Purchase, Accounting Defaults","Sprzedaż, zakup, domyślne ustawienia rachunkowości",
+Item Defaults,Domyślne elementy,
+"Purchase, Replenishment Details","Zakup, szczegóły uzupełnienia",
+Is Purchase Item,Jest pozycją kupowalną,
+Default Purchase Unit of Measure,Domyślna jednostka miary zakupów,
+Minimum Order Qty,Minimalna wartość zamówienia,
+Minimum quantity should be as per Stock UOM,Minimalna ilość powinna być zgodna z magazynową jednostką organizacyjną,
+Average time taken by the supplier to deliver,Średni czas podjęte przez dostawcę do dostarczenia,
+Is Customer Provided Item,Jest przedmiotem dostarczonym przez klienta,
+Delivered by Supplier (Drop Ship),Dostarczane przez Dostawcę (Drop Ship),
+Supplier Items,Dostawca przedmioty,
+Foreign Trade Details,Handlu Zagranicznego Szczegóły,
+Country of Origin,Kraj pochodzenia,
+Sales Details,Szczegóły sprzedaży,
+Default Sales Unit of Measure,Domyślna jednostka sprzedaży środka,
+Is Sales Item,Jest pozycją sprzedawalną,
+Max Discount (%),Maksymalny rabat (%),
+No of Months,Liczba miesięcy,
+Customer Items,Pozycje klientów,
+Inspection Criteria,Kryteria kontrolne,
+Inspection Required before Purchase,Wymagane Kontrola przed zakupem,
+Inspection Required before Delivery,Wymagane Kontrola przed dostawą,
+Default BOM,Domyślne Zestawienie Materiałów,
+Supply Raw Materials for Purchase,Dostawa surowce Skupu,
+If subcontracted to a vendor,Jeśli zlecona dostawcy,
+Customer Code,Kod Klienta,
+Default Item Manufacturer,Domyślny producent pozycji,
+Default Manufacturer Part No,Domyślny numer części producenta,
+Show in Website (Variant),Pokaż w Serwisie (Variant),
+Items with higher weightage will be shown higher,Produkty z wyższym weightage zostaną pokazane wyższe,
+Show a slideshow at the top of the page,Pokazuj slideshow na górze strony,
+Website Image,Obraz strony internetowej,
+Website Warehouse,Magazyn strony WWW,
+"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Pokazuj ""W magazynie"" lub ""Brak w magazynie"" bazując na ilości dostępnej w tym magazynie.",
+Website Item Groups,Grupy przedmiotów strony WWW,
+List this Item in multiple groups on the website.,Pokaż ten produkt w wielu grupach na stronie internetowej.,
+Copy From Item Group,Skopiuj z Grupy Przedmiotów,
+Website Content,Zawartość strony internetowej,
+You can use any valid Bootstrap 4 markup in this field. It will be shown on your Item Page.,Możesz użyć dowolnego poprawnego znacznika Bootstrap 4 w tym polu. Zostanie on wyświetlony na Twojej stronie przedmiotu.,
+Total Projected Qty,Łącznej prognozowanej szt,
+Hub Publishing Details,Szczegóły publikacji wydawnictwa Hub,
+Publish in Hub,Publikowanie w Hub,
+Publish Item to hub.erpnext.com,Publikacja na hub.erpnext.com,
+Hub Category to Publish,Kategoria ośrodka do opublikowania,
+Hub Warehouse,Magazyn Hub,
+"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Opublikuj &quot;W magazynie&quot; lub &quot;Nie w magazynie&quot; w Hub na podstawie zapasów dostępnych w tym magazynie.,
+Synced With Hub,Synchronizowane z Hub,
+Item Alternative,Pozycja alternatywna,
+Alternative Item Code,Alternatywny kod towaru,
+Two-way,Dwukierunkowy,
+Alternative Item Name,Alternatywna nazwa przedmiotu,
+Attribute Name,Nazwa atrybutu,
+Numeric Values,Wartości liczbowe,
+From Range,Od zakresu,
+Increment,Przyrost,
+To Range,Do osiągnięcia,
+Item Attribute Values,Wartości atrybutu elementu,
+Item Attribute Value,Pozycja wartość atrybutu,
+Attribute Value,Wartość atrybutu,
+Abbreviation,Skrót,
+"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","To będzie dołączany do Kodeksu poz wariantu. Na przykład, jeśli skrót to ""SM"", a kod element jest ""T-SHIRT"" Kod poz wariantu będzie ""T-SHIRT-SM""",
+Item Barcode,Kod kreskowy,
+Barcode Type,Typ kodu kreskowego,
+EAN,EAN,
+UPC-A,UPC-A,
+Item Customer Detail,Element Szczegóły klienta,
+"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Dla wygody klientów, te kody mogą być użyte w formacie drukowania jak faktury czy dowody dostawy",
+Ref Code,Ref kod,
+Item Default,Domyślny produkt,
+Purchase Defaults,Zakup domyślne,
+Default Buying Cost Center,Domyślne Centrum Kosztów Kupowania,
+Default Supplier,Domyślny dostawca,
+Default Expense Account,Domyślne konto rozchodów,
+Sales Defaults,Domyślne wartości sprzedaży,
+Default Selling Cost Center,Domyślne centrum kosztów sprzedaży,
+Item Manufacturer,pozycja Producent,
+Item Price,Cena,
+Packing Unit,Jednostka pakująca,
+Quantity  that must be bought or sold per UOM,"Ilość, która musi zostać kupiona lub sprzedana za MOM",
+Item Quality Inspection Parameter,Element Parametr Inspekcja Jakości,
+Acceptance Criteria,Kryteria akceptacji,
+Item Reorder,Element Zamów ponownie,
+Check in (group),Przyjazd (grupa),
+Request for,Wniosek o,
+Re-order Level,Próg ponowienia zamówienia,
+Re-order Qty,Ilość w ponowieniu zamówienia,
+Item Supplier,Dostawca,
+Item Variant,Pozycja Wersja,
+Item Variant Attribute,Pozycja Wersja Atrybut,
+Do not update variants on save,Nie aktualizuj wariantów przy zapisie,
+Fields will be copied over only at time of creation.,Pola będą kopiowane tylko w momencie tworzenia.,
+Allow Rename Attribute Value,Zezwalaj na zmianę nazwy wartości atrybutu,
+Rename Attribute Value in Item Attribute.,Zmień nazwę atrybutu w atrybucie elementu.,
+Copy Fields to Variant,Skopiuj pola do wariantu,
+Item Website Specification,Element Specyfikacja Strony,
+Table for Item that will be shown in Web Site,"Tabela dla pozycji, które zostaną pokazane w Witrynie",
+Landed Cost Item,Koszt Przedmiotu,
+Receipt Document Type,Otrzymanie Rodzaj dokumentu,
+Receipt Document,Otrzymanie dokumentu,
+Applicable Charges,Obowiązujące opłaty,
+Purchase Receipt Item,Przedmiot Potwierdzenia Zakupu,
+Landed Cost Purchase Receipt,Koszt kupionego przedmiotu,
+Landed Cost Taxes and Charges,Koszt podatków i opłat,
+Landed Cost Voucher,Koszt kuponu,
+MAT-LCV-.YYYY.-,MAT-LCV-.YYYY.-,
+Purchase Receipts,Potwierdzenia Zakupu,
+Purchase Receipt Items,Przedmioty Potwierdzenia Zakupu,
+Get Items From Purchase Receipts,Uzyskaj pozycje z potwierdzeń zakupu.,
+Distribute Charges Based On,Rozpowszechnianie opłat na podstawie,
+Landed Cost Help,Ugruntowany Koszt Pomocy,
+Manufacturers used in Items,Producenci używane w pozycji,
+Limited to 12 characters,Ograniczona do 12 znaków,
+MAT-MR-.YYYY.-,MAT-MR-.RRRR.-,
+Partially Ordered,Częściowo zamówione,
+Transferred,Przeniesiony,
+% Ordered,% Zamówione,
+Terms and Conditions Content,Zawartość regulaminu,
+Quantity and Warehouse,Ilość i magazyn,
+Lead Time Date,Termin realizacji,
+Min Order Qty,Min. wartość zamówienia,
+Packed Item,Przedmiot pakowany,
+To Warehouse (Optional),Aby Warehouse (opcjonalnie),
+Actual Batch Quantity,Rzeczywista ilość partii,
+Prevdoc DocType,Typ dokumentu dla poprzedniego dokumentu,
+Parent Detail docname,Nazwa dokumentu ze szczegółami nadrzędnego rodzica,
+"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Utwórz paski na opakowania do dostawy. Używane do informacji o numerze opakowania, zawartości i wadze.",
+Indicates that the package is a part of this delivery (Only Draft),"Wskazuje, że pakiet jest częścią tej dostawy (Tylko projektu)",
+MAT-PAC-.YYYY.-,MAT-PAC-.YYYY.-,
+From Package No.,Nr Przesyłki,
+Identification of the package for the delivery (for print),Nr identyfikujący paczkę do dostawy (do druku),
+To Package No.,Do zapakowania Nr,
+If more than one package of the same type (for print),Jeśli więcej niż jedna paczka tego samego typu (do druku),
+Package Weight Details,Informacje o wadze paczki,
+The net weight of this package. (calculated automatically as sum of net weight of items),Masa netto tego pakietu. (Obliczone automatycznie jako suma masy netto poszczególnych pozycji),
+Net Weight UOM,Jednostka miary wagi netto,
+Gross Weight,Waga brutto,
+The gross weight of the package. Usually net weight + packaging material weight. (for print),Waga brutto opakowania. Zazwyczaj waga netto + waga materiału z jakiego jest wykonane opakowanie. (Do druku),
+Gross Weight UOM,Waga brutto Jednostka miary,
+Packing Slip Item,Pozycja listu przewozowego,
+STO-PICK-.YYYY.-,STO-PICK-.YYYY.-,
+Material Transfer for Manufacture,Materiał transferu dla Produkcja,
+Qty of raw materials will be decided based on the qty of the Finished Goods Item,Ilość surowców zostanie ustalona na podstawie ilości produktu gotowego,
+Parent Warehouse,Dominująca Magazyn,
+Items under this warehouse will be suggested,Produkty w tym magazynie zostaną zasugerowane,
+Get Item Locations,Uzyskaj lokalizacje przedmiotów,
+Item Locations,Lokalizacje przedmiotów,
+Pick List Item,Wybierz element listy,
+Picked Qty,Wybrano ilość,
+Price List Master,Ustawienia Cennika,
+Price List Name,Nazwa cennika,
+Price Not UOM Dependent,Cena nie zależy od ceny,
+Applicable for Countries,Zastosowanie dla krajów,
+Price List Country,Cena Kraj,
+MAT-PRE-.YYYY.-,MAT-PRE-RAYY.-,
+Supplier Delivery Note,Uwagi do dostawy,
+Time at which materials were received,Data i czas otrzymania dostawy,
+Return Against Purchase Receipt,Powrót Przeciwko ZAKUPU,
+Rate at which supplier's currency is converted to company's base currency,Stawka przy użyciu której waluta dostawcy jest konwertowana do podstawowej waluty firmy,
+Sets 'Accepted Warehouse' in each row of the items table.,Ustawia „Zaakceptowany magazyn” w każdym wierszu tabeli towarów.,
+Sets 'Rejected Warehouse' in each row of the items table.,Ustawia „Magazyn odrzucony” w każdym wierszu tabeli towarów.,
+Raw Materials Consumed,Zużyte surowce,
+Get Current Stock,Pobierz aktualny stan magazynowy,
+Consumed Items,Zużyte przedmioty,
+Auto Repeat Detail,Auto Repeat Detail,
+Transporter Details,Szczegóły transportu,
+Vehicle Number,Numer pojazdu,
+Vehicle Date,Pojazd Data,
+Received and Accepted,Otrzymano i zaakceptowano,
+Accepted Quantity,Przyjęta Ilość,
+Rejected Quantity,Odrzucona Ilość,
+Accepted Qty as per Stock UOM,Zaakceptowana ilość zgodnie z JM zapasów,
+Sample Quantity,Ilość próbki,
+Rate and Amount,Stawka i Ilość,
+MAT-QA-.YYYY.-,MAT-QA-.YYYY.-,
+Report Date,Data raportu,
+Inspection Type,Typ kontroli,
+Item Serial No,Nr seryjny,
+Sample Size,Wielkość próby,
+Inspected By,Skontrolowane przez,
+Readings,Odczyty,
+Quality Inspection Reading,Odczyt kontroli jakości,
+Reading 1,Odczyt 1,
+Reading 2,Odczyt 2,
+Reading 3,Odczyt 3,
+Reading 4,Odczyt 4,
+Reading 5,Odczyt 5,
+Reading 6,Odczyt 6,
+Reading 7,Odczyt 7,
+Reading 8,Odczyt 8,
+Reading 9,Odczyt 9,
+Reading 10,Odczyt 10,
+Quality Inspection Template Name,Nazwa szablonu kontroli jakości,
+Quick Stock Balance,Szybkie saldo zapasów,
+Available Quantity,Dostępna Ilość,
+Distinct unit of an Item,Odrębna jednostka przedmiotu,
+Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Magazyn może być tylko zmieniony poprzez Wpis Asortymentu / Notę Dostawy / Potwierdzenie zakupu,
+Purchase / Manufacture Details,Szczegóły Zakupu / Produkcji,
+Creation Date,Data utworzenia,
+Creation Time,Czas utworzenia,
+Asset Details,Szczegóły dotyczące aktywów,
+Asset Status,Status zasobu,
+Delivery Document Type,Typ dokumentu dostawy,
+Delivery Document No,Nr dokumentu dostawy,
+Delivery Time,Czas dostawy,
+Invoice Details,Dane do faktury,
+Warranty / AMC Details,Gwarancja / AMC Szczegóły,
+Warranty Expiry Date,Data upływu gwarancji,
+AMC Expiry Date,AMC Data Ważności,
+Under Warranty,Pod Gwarancją,
+Out of Warranty,Brak Gwarancji,
+Under AMC,Pod AMC,
+Warranty Period (Days),Okres gwarancji (dni),
+Serial No Details,Szczegóły numeru seryjnego,
+MAT-STE-.YYYY.-,MAT-STE-.YYYY.-,
+Stock Entry Type,Rodzaj wejścia na magazyn,
+Stock Entry (Outward GIT),Wjazd na giełdę (GIT zewnętrzny),
+Material Consumption for Manufacture,Zużycie materiału do produkcji,
+Repack,Przepakowanie,
+Send to Subcontractor,Wyślij do Podwykonawcy,
+Delivery Note No,Nr dowodu dostawy,
+Sales Invoice No,Nr faktury sprzedaży,
+Purchase Receipt No,Nr Potwierdzenia Zakupu,
+Inspection Required,Wymagana kontrola,
+From BOM,Od BOM,
+For Quantity,Dla Ilości,
+Including items for sub assemblies,W tym elementów dla zespołów sub,
+Default Source Warehouse,Domyślny magazyn źródłowy,
+Source Warehouse Address,Adres hurtowni,
+Default Target Warehouse,Domyślny magazyn docelowy,
+Target Warehouse Address,Docelowy adres hurtowni,
+Update Rate and Availability,Aktualizuj cenę i dostępność,
+Total Incoming Value,Całkowita wartość przychodów,
+Total Outgoing Value,Całkowita wartość wychodząca,
+Total Value Difference (Out - In),Całkowita Wartość Różnica (Out - In),
+Additional Costs,Dodatkowe koszty,
+Total Additional Costs,Wszystkich Dodatkowe koszty,
+Customer or Supplier Details,Szczegóły klienta lub dostawcy,
+Per Transferred,Na przeniesione,
+Stock Entry Detail,Szczególy zapisu magazynowego,
+Basic Rate (as per Stock UOM),Stawki podstawowej (zgodnie Stock UOM),
+Basic Amount,Kwota podstawowa,
+Additional Cost,Dodatkowy koszt,
+Serial No / Batch,Nr seryjny / partia,
+Subcontracted Item,Element podwykonawstwa,
+Against Stock Entry,Przeciwko wprowadzeniu akcji,
+Stock Entry Child,Dziecko do wejścia na giełdę,
+PO Supplied Item,PO Dostarczony przedmiot,
+Reference Purchase Receipt,Odbiór zakupu referencyjnego,
+Stock Ledger Entry,Zapis w księdze zapasów,
+Outgoing Rate,Wychodzące Cena,
+Actual Qty After Transaction,Rzeczywista Ilość Po Transakcji,
+Stock Value Difference,Różnica wartości zapasów,
+Stock Reconciliation,Uzgodnienia stanu,
+This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,To narzędzie pomaga uaktualnić lub ustalić ilość i wycenę akcji w systemie. To jest zwykle używany do synchronizacji wartości systemowych i co rzeczywiście istnieje w magazynach.,
+MAT-RECO-.YYYY.-,MAT-RECO-.RRRR.-,
+Reconciliation JSON,Wyrównywanie JSON,
+Stock Reconciliation Item,Uzgodnienia Stanu Pozycja,
+Before reconciliation,Przed pojednania,
+Current Serial No,Aktualny numer seryjny,
+Current Valuation Rate,Aktualny Wycena Cena,
+Current Amount,Aktualny Kwota,
+Quantity Difference,Ilość Różnica,
+Amount Difference,kwota różnicy,
+Item Naming By,Element Nazwy przez,
+Default Item Group,Domyślna grupa elementów,
+Default Stock UOM,Domyślna jednostka miary Asortymentu,
+Sample Retention Warehouse,Przykładowy magazyn retencyjny,
+Default Valuation Method,Domyślna metoda wyceny,
+Show Barcode Field,Pokaż pole kodu kreskowego,
+Convert Item Description to Clean HTML,"Konwertuj opis elementu, aby wyczyścić HTML",
+Allow Negative Stock,Dozwolony ujemny stan,
+Automatically Set Serial Nos based on FIFO,Nr seryjny automatycznie ustawiony w oparciu o FIFO,
+Auto Material Request,Zapytanie Auto Materiał,
+Inter Warehouse Transfer Settings,Ustawienia transferu między magazynami,
+Freeze Stock Entries,Zamroź Wpisy do Asortymentu,
+Stock Frozen Upto,Zamroź zapasy do,
+Batch Identification,Identyfikacja partii,
+Use Naming Series,Użyj serii nazw,
+Naming Series Prefix,Prefiks serii nazw,
+UOM Category,Kategoria UOM,
+UOM Conversion Detail,Szczegóły konwersji jednostki miary,
+Variant Field,Pole wariantu,
+A logical Warehouse against which stock entries are made.,Logiczny Magazyn przeciwny do zapisów.,
+Warehouse Detail,Szczegóły magazynu,
+Warehouse Name,Nazwa magazynu,
+Warehouse Contact Info,Dane kontaktowe dla magazynu,
+PIN,PIN,
+ISS-.YYYY.-,ISS-.YYYY.-,
+Raised By (Email),Wywołany przez (Email),
+Issue Type,rodzaj zagadnienia,
+Issue Split From,Wydanie Split From,
+Service Level,Poziom usług,
+Response By,Odpowiedź wg,
+Response By Variance,Odpowiedź według wariancji,
+Ongoing,Trwający,
+Resolution By,Rozdzielczość wg,
+Resolution By Variance,Rozdzielczość przez wariancję,
+Service Level Agreement Creation,Tworzenie umowy o poziomie usług,
+First Responded On,Data pierwszej odpowiedzi,
+Resolution Details,Szczegóły Rozstrzygnięcia,
+Opening Date,Data Otwarcia,
+Opening Time,Czas Otwarcia,
+Resolution Date,Data Rozstrzygnięcia,
+Via Customer Portal,Przez portal klienta,
+Support Team,Support Team,
+Issue Priority,Priorytet wydania,
+Service Day,Dzień obsługi,
+Workday,Dzień roboczy,
+Default Priority,Domyślny priorytet,
+Priorities,Priorytety,
+Support Hours,Godziny Wsparcia,
+Support and Resolution,Wsparcie i rozdzielczość,
+Default Service Level Agreement,Domyślna umowa o poziomie usług,
+Entity,Jednostka,
+Agreement Details,Szczegóły umowy,
+Response and Resolution Time,Czas odpowiedzi i rozdzielczości,
+Service Level Priority,Priorytet poziomu usług,
+Resolution Time,Czas rozdzielczości,
+Support Search Source,Wspieraj źródło wyszukiwania,
+Source Type,rodzaj źródła,
+Query Route String,Ciąg trasy zapytania,
+Search Term Param Name,Szukane słowo Nazwa Param,
+Response Options,Opcje odpowiedzi,
+Response Result Key Path,Kluczowa ścieżka odpowiedzi,
+Post Route String,Wpisz ciąg trasy,
+Post Route Key List,Opublikuj listę kluczy,
+Post Title Key,Post Title Key,
+Post Description Key,Klucz opisu postu,
+Link Options,Opcje linku,
+Source DocType,Źródło DocType,
+Result Title Field,Pole wyniku wyniku,
+Result Preview Field,Pole podglądu wyników,
+Result Route Field,Wynik Pole trasy,
+Service Level Agreements,Umowy o poziomie usług,
+Track Service Level Agreement,Śledź umowę o poziomie usług,
+Allow Resetting Service Level Agreement,Zezwalaj na resetowanie umowy o poziomie usług,
+Close Issue After Days,Po blisko Issue Dni,
+Auto close Issue after 7 days,Auto blisko Issue po 7 dniach,
+Support Portal,Portal wsparcia,
+Get Started Sections,Pierwsze kroki,
+Show Latest Forum Posts,Pokaż najnowsze posty na forum,
+Forum Posts,Posty na forum,
+Forum URL,URL forum,
+Get Latest Query,Pobierz najnowsze zapytanie,
+Response Key List,Lista kluczy odpowiedzi,
+Post Route Key,Wpisz klucz trasy,
+Search APIs,Wyszukaj interfejsy API,
+SER-WRN-.YYYY.-,SER-WRN-.RRRR.-,
+Issue Date,Data zdarzenia,
+Item and Warranty Details,Przedmiot i gwarancji Szczegóły,
+Warranty / AMC Status,Gwarancja / AMC Status,
+Resolved By,Rozstrzygnięte przez,
+Service Address,Adres usługi,
+If different than customer address,Jeśli jest inny niż adres klienta,
+Raised By,Wywołany przez,
+From Company,Od Firmy,
+Rename Tool,Zmień nazwę narzędzia,
+Utilities,Usługi komunalne,
+Type of document to rename.,"Typ dokumentu, którego zmieniasz nazwę",
+File to Rename,Plik to zmiany nazwy,
+"Attach .csv file with two columns, one for the old name and one for the new name","Dołączyć plik .csv z dwoma kolumnami, po jednym dla starej nazwy i jeden dla nowej nazwy",
+Rename Log,Zmień nazwę dziennika,
+SMS Log,Dziennik zdarzeń SMS,
+Sender Name,Nazwa Nadawcy,
+Sent On,Wysłano w,
+No of Requested SMS,Numer wymaganego SMS,
+Requested Numbers,Wymagane numery,
+No of Sent SMS,Numer wysłanego Sms,
+Sent To,Wysłane Do,
+Absent Student Report,Raport Nieobecności Studenta,
+Assessment Plan Status,Status planu oceny,
+Asset Depreciation Ledger,Księga amortyzacji,
+Asset Depreciations and Balances,Aktywów Amortyzacja i salda,
+Available Stock for Packing Items,Dostępne ilości dla materiałów opakunkowych,
+Bank Clearance Summary,Rozliczenia bankowe,
+Bank Remittance,Przelew bankowy,
+Batch Item Expiry Status,Batch Przedmiot status ważności,
+BOM Explorer,Eksplorator BOM,
+BOM Search,BOM Szukaj,
+BOM Stock Calculated,BOM Stock Obliczono,
+BOM Variance Report,Raport wariancji BOM,
+Campaign Efficiency,Skuteczność Kampanii,
+Cash Flow,Przepływy pieniężne,
+Completed Work Orders,Zrealizowane zlecenia pracy,
+To Produce,Do produkcji,
+Produced,Wyprodukowany,
+Consolidated Financial Statement,Skonsolidowane sprawozdanie finansowe,
+Course wise Assessment Report,Szeregowy raport oceny,
+Customer Credit Balance,Saldo kredytowe klienta,
+Customer Ledger Summary,Podsumowanie księgi klienta,
+Customer-wise Item Price,Cena przedmiotu pod względem klienta,
+Customers Without Any Sales Transactions,Klienci bez żadnych transakcji sprzedaży,
+Daily Timesheet Summary,Codzienne grafiku Podsumowanie,
+Daily Work Summary Replies,Podsumowanie codziennej pracy,
+DATEV,DATEV,
+Delayed Item Report,Raport o opóźnionych przesyłkach,
+Delayed Order Report,Raport o opóźnionym zamówieniu,
+Delivered Items To Be Billed,Dostarczone przedmioty oczekujące na fakturowanie,
+Delivery Note Trends,Trendy Dowodów Dostawy,
+Electronic Invoice Register,Rejestr faktur elektronicznych,
+Employee Advance Summary,Podsumowanie zaliczek pracowników,
+Employee Billing Summary,Podsumowanie płatności dla pracowników,
+Employee Birthday,Data urodzenia pracownika,
+Employee Information,Informacja o pracowniku,
+Employee Leave Balance,Bilans Nieobecności Pracownika,
+Employee Leave Balance Summary,Podsumowanie salda urlopu pracownika,
+Employees working on a holiday,Pracownicy zatrudnieni na wakacje,
+Eway Bill,Eway Bill,
+Expiring Memberships,Wygaśnięcie członkostwa,
+Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC],
+Final Assessment Grades,Oceny końcowe,
+Fixed Asset Register,Naprawiono rejestr aktywów,
+Gross and Net Profit Report,Raport zysku brutto i netto,
+GST Itemised Purchase Register,GST Wykaz zamówień zakupu,
+GST Itemised Sales Register,Wykaz numerów sprzedaży produktów GST,
+GST Purchase Register,Rejestr zakupów GST,
+GST Sales Register,Rejestr sprzedaży GST,
+GSTR-1,GSTR-1,
+GSTR-2,GSTR-2,
+Hotel Room Occupancy,Pokój hotelowy,
+HSN-wise-summary of outward supplies,Podsumowanie HSN dostaw zewnętrznych,
+Inactive Customers,Nieaktywne Klienci,
+Inactive Sales Items,Nieaktywne elementy sprzedaży,
+IRS 1099,IRS 1099,
+Issued Items Against Work Order,Wydane przedmioty na zlecenie pracy,
+Projected Quantity as Source,Prognozowana ilość jako źródło,
+Item Balance (Simple),Bilans przedmiotu (prosty),
+Item Price Stock,Pozycja Cena towaru,
+Item Prices,Ceny,
+Item Shortage Report,Element Zgłoś Niedobór,
+Item Variant Details,Szczegóły wariantu przedmiotu,
+Reserved,Zarezerwowany,
+Itemwise Recommended Reorder Level,Pozycja Zalecany poziom powtórnego zamówienia,
+Lead Details,Dane Tropu,
+Lead Owner Efficiency,Skuteczność właściciela wiodącego,
+Loan Repayment and Closure,Spłata i zamknięcie pożyczki,
+Loan Security Status,Status zabezpieczenia pożyczki,
+Lost Opportunity,Stracona szansa,
+Maintenance Schedules,Plany Konserwacji,
+Monthly Attendance Sheet,Miesięczna karta obecności,
+Open Work Orders,Otwórz zlecenia pracy,
+Qty to Deliver,Ilość do dostarczenia,
+Patient Appointment Analytics,Analiza wizyt pacjentów,
+Payment Period Based On Invoice Date,Termin Płatności oparty na dacie faktury,
+Pending SO Items For Purchase Request,Oczekiwane elementy Zamówień Sprzedaży na Prośbę Zakupu,
+Procurement Tracker,Śledzenie zamówień,
+Product Bundle Balance,Bilans pakietu produktów,
+Production Analytics,Analizy produkcyjne,
+Profit and Loss Statement,Rachunek zysków i strat,
+Profitability Analysis,Analiza rentowności,
+Project Billing Summary,Podsumowanie płatności za projekt,
+Project wise Stock Tracking,Śledzenie zapasów według projektu,
+Prospects Engaged But Not Converted,"Perspektywy zaręczone, ale nie przekształcone",
+Purchase Analytics,Analiza Zakupów,
+Purchase Invoice Trends,Trendy Faktur Zakupów,
+Qty to Receive,Ilość do otrzymania,
+Received Qty Amount,Otrzymana ilość,
+Billed Qty,Rozliczona ilość,
+Purchase Order Trends,Trendy Zamówienia Kupna,
+Purchase Receipt Trends,Trendy Potwierdzenia Zakupu,
+Purchase Register,Rejestracja Zakupu,
+Quotation Trends,Trendy Wyceny,
+Received Items To Be Billed,Otrzymane przedmioty czekające na zaksięgowanie,
+Qty to Order,Ilość do zamówienia,
+Requested Items To Be Transferred,Proszę o Przetranferowanie Przedmiotów,
+Qty to Transfer,Ilość do transferu,
+Salary Register,wynagrodzenie Rejestracja,
+Sales Analytics,Analityka sprzedaży,
+Sales Partner Commission Summary,Podsumowanie Komisji ds. Sprzedaży,
+Sales Partner Target Variance based on Item Group,Zmienna docelowa partnera handlowego na podstawie grupy pozycji,
+Sales Partner Transaction Summary,Podsumowanie transakcji partnera handlowego,
+Sales Partners Commission,Prowizja Partnera Sprzedaży,
+Invoiced Amount (Exclusive Tax),Kwota zafakturowana (bez podatku),
+Average Commission Rate,Średnia Prowizja,
+Sales Payment Summary,Podsumowanie płatności za sprzedaż,
+Sales Person Commission Summary,Osoba odpowiedzialna za sprzedaż,
+Sales Person Target Variance Based On Item Group,Zmienna docelowa osoby sprzedaży na podstawie grupy pozycji,
+Sales Register,Rejestracja Sprzedaży,
+Serial No Service Contract Expiry,Umowa serwisowa o nr seryjnym wygasa,
+Serial No Status,Status nr seryjnego,
+Serial No Warranty Expiry,Gwarancja o nr seryjnym wygasa,
+Stock Ageing,Starzenie się zapasów,
+Stock and Account Value Comparison,Porównanie wartości zapasów i konta,
+Stock Projected Qty,Przewidywana ilość zapasów,
+Student and Guardian Contact Details,Uczeń i opiekun Dane kontaktowe,
+Student Batch-Wise Attendance,Partiami Student frekwencja,
+Student Fee Collection,Student Opłata Collection,
+Student Monthly Attendance Sheet,Student miesięczny Obecność Sheet,
+Subcontracted Item To Be Received,Przedmiot podwykonawstwa do odbioru,
+Subcontracted Raw Materials To Be Transferred,"Podwykonawstwo Surowce, które mają zostać przekazane",
+Supplier Ledger Summary,Podsumowanie księgi dostawców,
+Support Hour Distribution,Dystrybucja godzin wsparcia,
+TDS Computation Summary,Podsumowanie obliczeń TDS,
+TDS Payable Monthly,Miesięczny płatny TDS,
+Territory Target Variance Based On Item Group,Territory Target Variance Based On Item Item,
+Territory-wise Sales,Sprzedaż terytorialna,
+Total Stock Summary,Całkowity podsumowanie zasobów,
+Trial Balance,Zestawienie obrotów i sald,
+Trial Balance (Simple),Bilans próbny (prosty),
+Trial Balance for Party,Trial Balance for Party,
+Unpaid Expense Claim,Niepłatny Koszty Zastrzeżenie,
+Warehouse wise Item Balance Age and Value,Magazyn mądry Pozycja Bilans Wiek i wartość,
+Work Order Stock Report,Raport o stanie zlecenia pracy,
+Work Orders in Progress,Zlecenia robocze w toku,
+Validation Error,Błąd walidacji,
+Automatically Process Deferred Accounting Entry,Automatycznie przetwarzaj odroczony zapis księgowy,
+Bank Clearance,Rozliczenie bankowe,
+Bank Clearance Detail,Szczegóły dotyczące rozliczeń bankowych,
+Update Cost Center Name / Number,Zaktualizuj nazwę / numer centrum kosztów,
+Journal Entry Template,Szablon wpisu do dziennika,
+Template Title,Tytuł szablonu,
+Journal Entry Type,Typ pozycji dziennika,
+Journal Entry Template Account,Konto szablonu zapisów księgowych,
+Process Deferred Accounting,Rozliczanie odroczone procesu,
+Manual entry cannot be created! Disable automatic entry for deferred accounting in accounts settings and try again,Nie można utworzyć ręcznego wpisu! Wyłącz automatyczne wprowadzanie odroczonych księgowań w ustawieniach kont i spróbuj ponownie,
+End date cannot be before start date,Data zakończenia nie może być wcześniejsza niż data rozpoczęcia,
+Total Counts Targeted,Łączna liczba docelowa,
+Total Counts Completed,Całkowita liczba zakończonych,
+Counts Targeted: {0},Docelowe liczby: {0},
+Payment Account is mandatory,Konto płatnicze jest obowiązkowe,
+"If checked, the full amount will be deducted from taxable income before calculating income tax without any declaration or proof submission.","Jeśli zaznaczone, pełna kwota zostanie odliczona od dochodu podlegającego opodatkowaniu przed obliczeniem podatku dochodowego bez składania deklaracji lub dowodów.",
+Disbursement Details,Szczegóły wypłaty,
+Material Request Warehouse,Magazyn żądań materiałowych,
+Select warehouse for material requests,Wybierz magazyn dla zapytań materiałowych,
+Transfer Materials For Warehouse {0},Przenieś materiały do magazynu {0},
+Production Plan Material Request Warehouse,Plan produkcji Magazyn żądań materiałowych,
+Sets 'Source Warehouse' in each row of the items table.,Ustawia „Magazyn źródłowy” w każdym wierszu tabeli towarów.,
+Sets 'Target Warehouse' in each row of the items table.,Ustawia „Magazyn docelowy” w każdym wierszu tabeli towarów.,
+Show Cancelled Entries,Pokaż anulowane wpisy,
+Backdated Stock Entry,Zapis akcji z datą wsteczną,
+Row #{}: Currency of {} - {} doesn't matches company currency.,Wiersz nr {}: waluta {} - {} nie odpowiada walucie firmy.,
+{} Assets created for {},{} Zasoby utworzone dla {},
+{0} Number {1} is already used in {2} {3},{0} Numer {1} jest już używany w {2} {3},
+Update Bank Clearance Dates,Zaktualizuj daty rozliczeń bankowych,
+Healthcare Practitioner: ,Lekarz:,
+Lab Test Conducted: ,Przeprowadzony test laboratoryjny:,
+Lab Test Event: ,Wydarzenie testów laboratoryjnych:,
+Lab Test Result: ,Wynik testu laboratoryjnego:,
+Clinical Procedure conducted: ,Przeprowadzona procedura kliniczna:,
+Therapy Session Charges: {0},Opłaty za sesję terapeutyczną: {0},
+Therapy: ,Terapia:,
+Therapy Plan: ,Plan terapii:,
+Total Counts Targeted: ,Łączna liczba docelowa:,
+Total Counts Completed: ,Łączna liczba zakończonych:,
+Andaman and Nicobar Islands,Wyspy Andaman i Nicobar,
+Andhra Pradesh,Andhra Pradesh,
+Arunachal Pradesh,Arunachal Pradesh,
+Assam,Assam,
+Bihar,Bihar,
+Chandigarh,Chandigarh,
+Chhattisgarh,Chhattisgarh,
+Dadra and Nagar Haveli,Dadra i Nagar Haveli,
+Daman and Diu,Daman i Diu,
+Delhi,Delhi,
+Goa,Goa,
+Gujarat,Gujarat,
+Haryana,Haryana,
+Himachal Pradesh,Himachal Pradesh,
+Jammu and Kashmir,Dżammu i Kaszmir,
+Jharkhand,Jharkhand,
+Karnataka,Karnataka,
+Kerala,Kerala,
+Lakshadweep Islands,Wyspy Lakshadweep,
+Madhya Pradesh,Madhya Pradesh,
+Maharashtra,Maharashtra,
+Manipur,Manipur,
+Meghalaya,Meghalaya,
+Mizoram,Mizoram,
+Nagaland,Nagaland,
+Odisha,Odisha,
+Other Territory,Inne terytorium,
+Pondicherry,Puducherry,
+Punjab,Pendżab,
+Rajasthan,Rajasthan,
+Sikkim,Sikkim,
+Tamil Nadu,Tamil Nadu,
+Telangana,Telangana,
+Tripura,Tripura,
+Uttar Pradesh,Uttar Pradesh,
+Uttarakhand,Uttarakhand,
+West Bengal,Bengal Zachodni,
+Is Mandatory,Jest obowiązkowe,
+Published on,Opublikowano,
+Service Received But Not Billed,"Usługa otrzymana, ale niezafakturowana",
+Deferred Accounting Settings,Odroczone ustawienia księgowania,
+Book Deferred Entries Based On,Rezerwuj wpisy odroczone na podstawie,
+Days,Dni,
+Months,Miesięcy,
+Book Deferred Entries Via Journal Entry,Rezerwuj wpisy odroczone za pośrednictwem wpisu do dziennika,
+Submit Journal Entries,Prześlij wpisy do dziennika,
+If this is unchecked Journal Entries will be saved in a Draft state and will have to be submitted manually,"Jeśli ta opcja nie jest zaznaczona, wpisy do dziennika zostaną zapisane jako wersja robocza i będą musiały zostać przesłane ręcznie",
+Enable Distributed Cost Center,Włącz rozproszone centrum kosztów,
+Distributed Cost Center,Rozproszone centrum kosztów,
+Dunning,Dunning,
+DUNN-.MM.-.YY.-,DUNN-.MM .-. YY.-,
+Overdue Days,Zaległe dni,
+Dunning Type,Typ monitu,
+Dunning Fee,Opłata za monitowanie,
+Dunning Amount,Kwota monitu,
+Resolved,Zdecydowany,
+Unresolved,Nie rozwiązany,
+Printing Setting,Ustawienie drukowania,
+Body Text,Body Text,
+Closing Text,Tekst zamykający,
+Resolve,Rozwiązać,
+Dunning Letter Text,Tekst listu monitującego,
+Is Default Language,Jest językiem domyślnym,
+Letter or Email Body Text,Treść listu lub wiadomości e-mail,
+Letter or Email Closing Text,List lub e-mail zamykający tekst,
+Body and Closing Text Help,Pomoc dotycząca treści i tekstu zamykającego,
+Overdue Interval,Zaległy interwał,
+Dunning Letter,List monitujący,
+"This section allows the user to set the Body and Closing text of the Dunning Letter for the Dunning Type based on language, which can be used in Print.","W tej sekcji użytkownik może ustawić treść i treść listu upominającego dla typu monitu w oparciu o język, którego można używać w druku.",
+Reference Detail No,Numer referencyjny odniesienia,
+Custom Remarks,Uwagi niestandardowe,
+Please select a Company first.,Najpierw wybierz firmę.,
+"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice, Journal Entry or Dunning","Wiersz nr {0}: typem dokumentu referencyjnego musi być zamówienie sprzedaży, faktura sprzedaży, zapis księgowy lub monit",
+POS Closing Entry,Zamknięcie POS,
+POS Opening Entry,Otwarcie POS,
+POS Transactions,Transakcje POS,
+POS Closing Entry Detail,Szczegóły wejścia zamknięcia POS,
+Opening Amount,Kwota otwarcia,
+Closing Amount,Kwota zamknięcia,
+POS Closing Entry Taxes,Podatki przy wejściu przy zamykaniu POS,
+POS Invoice,Faktura POS,
+ACC-PSINV-.YYYY.-,ACC-PSINV-.YYYY.-,
+Consolidated Sales Invoice,Skonsolidowana faktura sprzedaży,
+Return Against POS Invoice,Zwrot na podstawie faktury POS,
+Consolidated,Skonsolidowany,
+POS Invoice Item,Pozycja faktury POS,
+POS Invoice Merge Log,Dziennik scalania faktur POS,
+POS Invoices,Faktury POS,
+Consolidated Credit Note,Skonsolidowana nota kredytowa,
+POS Invoice Reference,Numer faktury POS,
+Set Posting Date,Ustaw datę księgowania,
+Opening Balance Details,Szczegóły salda otwarcia,
+POS Opening Entry Detail,Szczegóły wejścia do punktu sprzedaży,
+POS Payment Method,Metoda płatności POS,
+Payment Methods,Metody Płatności,
+Process Statement Of Accounts,Przetwarzaj wyciągi z kont,
+General Ledger Filters,Filtry księgi głównej,
+Customers,Klienci,
+Select Customers By,Wybierz klientów według,
+Fetch Customers,Pobierz klientów,
+Send To Primary Contact,Wyślij do głównej osoby kontaktowej,
+Print Preferences,Preferencje drukowania,
+Include Ageing Summary,Uwzględnij podsumowanie starzenia się,
+Enable Auto Email,Włącz automatyczne e-maile,
+Filter Duration (Months),Czas trwania filtra (miesiące),
+CC To,CC To,
+Help Text,Tekst pomocy,
+Emails Queued,E-maile w kolejce,
+Process Statement Of Accounts Customer,Przetwarzaj wyciąg z kont Klient,
+Billing Email,E-mail rozliczeniowy,
+Primary Contact Email,Adres e-mail głównej osoby kontaktowej,
+PSOA Cost Center,Centrum kosztów PSOA,
+PSOA Project,Projekt PSOA,
+ACC-PINV-RET-.YYYY.-,ACC-PINV-RET-.YYYY.-,
+Supplier GSTIN,Dostawca GSTIN,
+Place of Supply,Miejsce dostawy,
+Select Billing Address,Wybierz Adres rozliczeniowy,
+GST Details,Szczegóły dotyczące podatku GST,
+GST Category,Kategoria podatku GST,
+Registered Regular,Zarejestrowany Regularny,
+Registered Composition,Zarejestrowany skład,
+Unregistered,Niezarejestrowany,
+SEZ,SSE,
+Overseas,Za granicą,
+UIN Holders,Posiadacze UIN,
+With Payment of Tax,Z zapłatą podatku,
+Without Payment of Tax,Bez zapłaty podatku,
+Invoice Copy,Kopia faktury,
+Original for Recipient,Oryginał dla Odbiorcy,
+Duplicate for Transporter,Duplikat dla Transportera,
+Duplicate for Supplier,Duplikat dla dostawcy,
+Triplicate for Supplier,Potrójny egzemplarz dla dostawcy,
+Reverse Charge,Opłata zwrotna,
+Y,Y,
+N,N,
+E-commerce GSTIN,GSTIN dla handlu elektronicznego,
+Reason For Issuing document,Przyczyna wystawienia dokumentu,
+01-Sales Return,01-Zwrot sprzedaży,
+02-Post Sale Discount,02-zniżka po sprzedaży,
+03-Deficiency in services,03-Niedobór usług,
+04-Correction in Invoice,04-Korekta na fakturze,
+05-Change in POS,05-Zmiana w POS,
+06-Finalization of Provisional assessment,06-Zakończenie wstępnej oceny,
+07-Others,07-Inne,
+Eligibility For ITC,Kwalifikowalność do ITC,
+Input Service Distributor,Dystrybutor usług wejściowych,
+Import Of Service,Import usług,
+Import Of Capital Goods,Import dóbr kapitałowych,
+Ineligible,Którego nie można wybrać,
+All Other ITC,Wszystkie inne ITC,
+Availed ITC Integrated Tax,Dostępny podatek zintegrowany ITC,
+Availed ITC Central Tax,Zastosowany podatek centralny ITC,
+Availed ITC State/UT Tax,Dostępny podatek stanowy ITC / UT,
+Availed ITC Cess,Dostępny podatek ITC,
+Is Nil Rated or Exempted,Brak oceny lub zwolnienie,
+Is Non GST,Nie zawiera podatku GST,
+ACC-SINV-RET-.YYYY.-,ACC-SINV-RET-.YYYY.-,
+E-Way Bill No.,E-Way Bill No.,
+Is Consolidated,Jest skonsolidowane,
+Billing Address GSTIN,Adres rozliczeniowy GSTIN,
+Customer GSTIN,GSTIN klienta,
+GST Transporter ID,Identyfikator przewoźnika GST,
+Distance (in km),Odległość (w km),
+Road,Droga,
+Air,Powietrze,
+Rail,Szyna,
+Ship,Statek,
+GST Vehicle Type,Typ pojazdu z podatkiem VAT,
+Over Dimensional Cargo (ODC),Ładunki ponadwymiarowe (ODC),
+Consumer,Konsument,
+Deemed Export,Uważany za eksport,
+Port Code,Kod portu,
+ Shipping Bill Number,Numer rachunku za wysyłkę,
+Shipping Bill Date,Data rachunku za wysyłkę,
+Subscription End Date,Data zakończenia subskrypcji,
+Follow Calendar Months,Śledź miesiące kalendarzowe,
+If this is checked subsequent new invoices will be created on calendar  month and quarter start dates irrespective of current invoice start date,"Jeśli ta opcja jest zaznaczona, kolejne nowe faktury będą tworzone w datach rozpoczęcia miesiąca kalendarzowego i kwartału, niezależnie od daty rozpoczęcia aktualnej faktury",
+Generate New Invoices Past Due Date,Wygeneruj nowe faktury przeterminowane,
+New invoices will be generated as per schedule even if current invoices are unpaid or past due date,"Nowe faktury będą generowane zgodnie z harmonogramem, nawet jeśli bieżące faktury są niezapłacone lub przeterminowane",
+Document Type ,typ dokumentu,
+Subscription Price Based On,Cena subskrypcji na podstawie,
+Fixed Rate,Stała stawka,
+Based On Price List,Na podstawie cennika,
+Monthly Rate,Opłata miesięczna,
+Cancel Subscription After Grace Period,Anuluj subskrypcję po okresie prolongaty,
+Source State,Stan źródłowy,
+Is Inter State,Jest międzystanowe,
+Purchase Details,Szczegóły zakupu,
+Depreciation Posting Date,Data księgowania amortyzacji,
+"By default, the Supplier Name is set as per the Supplier Name entered. If you want Suppliers to be named by a  ","Domyślnie nazwa dostawcy jest ustawiona zgodnie z wprowadzoną nazwą dostawcy. Jeśli chcesz, aby dostawcy byli nazwani przez rozszerzenie",
+ choose the 'Naming Series' option.,wybierz opcję „Naming Series”.,
+Configure the default Price List when creating a new Purchase transaction. Item prices will be fetched from this Price List.,Skonfiguruj domyślny Cennik podczas tworzenia nowej transakcji zakupu. Ceny pozycji zostaną pobrane z tego Cennika.,
+"If this option is configured 'Yes', ERPNext will prevent you from creating a Purchase Invoice or Receipt without creating a Purchase Order first. This configuration can be overridden for a particular supplier by enabling the 'Allow Purchase Invoice Creation Without Purchase Order' checkbox in the Supplier master.","Jeśli ta opcja jest skonfigurowana jako „Tak”, ERPNext uniemożliwi utworzenie faktury zakupu lub paragonu bez wcześniejszego tworzenia zamówienia. Tę konfigurację można zastąpić dla określonego dostawcy, zaznaczając pole wyboru „Zezwalaj na tworzenie faktur zakupu bez zamówienia” w karcie głównej dostawcy.",
+"If this option is configured 'Yes', ERPNext will prevent you from creating a Purchase Invoice without creating a Purchase Receipt first. This configuration can be overridden for a particular supplier by enabling the 'Allow Purchase Invoice Creation Without Purchase Receipt' checkbox in the Supplier master.","Jeśli ta opcja jest skonfigurowana jako „Tak”, ERPNext uniemożliwi utworzenie faktury zakupu bez uprzedniego tworzenia paragonu zakupu. Tę konfigurację można zastąpić dla określonego dostawcy, zaznaczając pole wyboru „Zezwalaj na tworzenie faktur zakupu bez potwierdzenia zakupu” we wzorcu dostawcy.",
+Quantity & Stock,Ilość i stan magazynowy,
+Call Details,Szczegóły połączenia,
+Authorised By,Zaautoryzowany przez,
+Signee (Company),Signee (firma),
+Signed By (Company),Podpisane przez (firma),
+First Response Time,Czas pierwszej odpowiedzi,
+Request For Quotation,Zapytanie ofertowe,
+Opportunity Lost Reason Detail,Szczegóły utraconego powodu możliwości,
+Access Token Secret,Dostęp do klucza tajnego,
+Add to Topics,Dodaj do tematów,
+...Adding Article to Topics,... Dodawanie artykułu do tematów,
+Add Article to Topics,Dodaj artykuł do tematów,
+This article is already added to the existing topics,Ten artykuł jest już dodany do istniejących tematów,
+Add to Programs,Dodaj do programów,
+Programs,Programy,
+...Adding Course to Programs,... Dodawanie kursu do programów,
+Add Course to Programs,Dodaj kurs do programów,
+This course is already added to the existing programs,Ten kurs jest już dodany do istniejących programów,
+Learning Management System Settings,Ustawienia systemu zarządzania nauką,
+Enable Learning Management System,Włącz system zarządzania nauką,
+Learning Management System Title,Tytuł systemu zarządzania nauczaniem,
+...Adding Quiz to Topics,... Dodawanie quizu do tematów,
+Add Quiz to Topics,Dodaj quiz do tematów,
+This quiz is already added to the existing topics,Ten quiz został już dodany do istniejących tematów,
+Enable Admission Application,Włącz aplikację o przyjęcie,
+EDU-ATT-.YYYY.-,EDU-ATT-.YYYY.-,
+Marking attendance,Oznaczanie obecności,
+Add Guardians to Email Group,Dodaj opiekunów do grupy e-mailowej,
+Attendance Based On,Frekwencja na podstawie,
+Check this to mark the student as present in case the student is not attending the institute to participate or represent the institute in any event.\n\n,"Zaznacz to, aby oznaczyć ucznia jako obecnego na wypadek, gdyby student nie uczęszczał do instytutu, aby w żadnym wypadku uczestniczyć lub reprezentować instytut.",
+Add to Courses,Dodaj do kursów,
+...Adding Topic to Courses,... Dodawanie tematu do kursów,
+Add Topic to Courses,Dodaj temat do kursów,
+This topic is already added to the existing courses,Ten temat jest już dodany do istniejących kursów,
+"If Shopify does not have a customer in the order, then while syncing the orders, the system will consider the default customer for the order","Jeśli Shopify nie ma klienta w zamówieniu, to podczas synchronizacji zamówień system weźmie pod uwagę domyślnego klienta dla zamówienia",
+The accounts are set by the system automatically but do confirm these defaults,"Konta są ustawiane przez system automatycznie, ale potwierdzają te ustawienia domyślne",
+Default Round Off Account,Domyślne konto zaokrągleń,
+Failed Import Log,Nieudany import dziennika,
+Fixed Error Log,Naprawiono dziennik błędów,
+Company {0} already exists. Continuing will overwrite the Company and Chart of Accounts,Firma {0} już istnieje. Kontynuacja spowoduje nadpisanie firmy i planu kont,
+Meta Data,Metadane,
+Unresolve,Nierozwiązane,
+Create Document,Utwórz dokument,
+Mark as unresolved,Oznacz jako nierozwiązane,
+TaxJar Settings,Ustawienia TaxJar,
+Sandbox Mode,Tryb piaskownicy,
+Enable Tax Calculation,Włącz obliczanie podatku,
+Create TaxJar Transaction,Utwórz transakcję TaxJar,
+Credentials,Kwalifikacje,
+Live API Key,Aktywny klucz API,
+Sandbox API Key,Klucz API piaskownicy,
+Configuration,Konfiguracja,
+Tax Account Head,Szef konta podatkowego,
+Shipping Account Head,Szef konta wysyłkowego,
+Practitioner Name,Nazwisko lekarza,
+Enter a name for the Clinical Procedure Template,Wprowadź nazwę szablonu procedury klinicznej,
+Set the Item Code which will be used for billing the Clinical Procedure.,"Ustaw kod pozycji, który będzie używany do rozliczenia procedury klinicznej.",
+Select an Item Group for the Clinical Procedure Item.,Wybierz grupę pozycji dla pozycji procedury klinicznej.,
+Clinical Procedure Rate,Częstość zabiegów klinicznych,
+Check this if the Clinical Procedure is billable and also set the rate.,"Sprawdź, czy procedura kliniczna podlega opłacie, a także ustaw stawkę.",
+Check this if the Clinical Procedure utilises consumables. Click ,"Sprawdź to, jeśli procedura kliniczna wykorzystuje materiały eksploatacyjne. Kliknij",
+ to know more,wiedzieć więcej,
+"You can also set the Medical Department for the template. After saving the document, an Item will automatically be created for billing this Clinical Procedure. You can then use this template while creating Clinical Procedures for Patients. Templates save you from filling up redundant data every single time. You can also create templates for other operations like Lab Tests, Therapy Sessions, etc.","Możesz również ustawić dział medyczny dla szablonu. Po zapisaniu dokumentu pozycja zostanie automatycznie utworzona do rozliczenia tej procedury klinicznej. Możesz następnie użyć tego szablonu podczas tworzenia procedur klinicznych dla pacjentów. Szablony chronią Cię przed zapełnianiem zbędnych danych za każdym razem. Możesz także tworzyć szablony dla innych operacji, takich jak testy laboratoryjne, sesje terapeutyczne itp.",
+Descriptive Test Result,Opisowy wynik testu,
+Allow Blank,Pozwól puste,
+Descriptive Test Template,Opisowy szablon testu,
+"If you want to track Payroll and other HRMS operations for a Practitoner, create an Employee and link it here.","Jeśli chcesz śledzić listę płac i inne operacje HRMS dla praktyka, utwórz pracownika i połącz go tutaj.",
+Set the Practitioner Schedule you just created. This will be used while booking appointments.,Ustaw właśnie utworzony harmonogram lekarza. Będzie on używany podczas rezerwacji spotkań.,
+Create a service item for Out Patient Consulting.,Utwórz pozycję usługi dla konsultacji z pacjentami zewnętrznymi.,
+"If this Healthcare Practitioner works for the In-Patient Department, create a service item for Inpatient Visits.","Jeśli ten pracownik służby zdrowia pracuje dla oddziału szpitalnego, utwórz pozycję usługi dla wizyt szpitalnych.",
+Set the Out Patient Consulting Charge for this Practitioner.,Ustaw opłatę za konsultacje pacjenta zewnętrznego dla tego lekarza.,
+"If this Healthcare Practitioner also works for the In-Patient Department, set the inpatient visit charge for this Practitioner.","Jeśli ten lekarz pracuje również dla oddziału szpitalnego, ustal opłatę za wizytę w szpitalu dla tego lekarza.",
+"If checked, a customer will be created for every Patient. Patient Invoices will be created against this Customer. You can also select existing Customer while creating a Patient. This field is checked by default.","Jeśli zaznaczone, dla każdego Pacjenta zostanie utworzony klient. Dla tego klienta zostaną utworzone faktury dla pacjenta. Możesz także wybrać istniejącego klienta podczas tworzenia pacjenta. To pole jest domyślnie zaznaczone.",
+Collect Registration Fee,Pobrać opłatę rejestracyjną,
+"If your Healthcare facility bills registrations of Patients, you can check this and set the Registration Fee in the field below. Checking this will create new Patients with a Disabled status by default and will only be enabled after invoicing the Registration Fee.","Jeśli Twoja placówka medyczna wystawia rachunki za rejestracje pacjentów, możesz to sprawdzić i ustawić Opłatę rejestracyjną w polu poniżej. Zaznaczenie tej opcji spowoduje domyślnie utworzenie nowych pacjentów ze statusem Wyłączony i będzie włączone dopiero po zafakturowaniu Opłaty rejestracyjnej.",
+Checking this will automatically create a Sales Invoice whenever an appointment is booked for a Patient.,"Zaznaczenie tego spowoduje automatyczne utworzenie faktury sprzedaży za każdym razem, gdy zostanie zarezerwowane spotkanie dla Pacjenta.",
+Healthcare Service Items,Elementy usług opieki zdrowotnej,
+"You can create a service item for Inpatient Visit Charge and set it here. Similarly, you can set up other Healthcare Service Items for billing in this section. Click ","Możesz utworzyć pozycję usługi dla opłaty za wizytę szpitalną i ustawić ją tutaj. Podobnie, w tej sekcji możesz skonfigurować inne pozycje usług opieki zdrowotnej do rozliczeń. Kliknij",
+Set up default Accounts for the Healthcare Facility,Skonfiguruj domyślne konta dla placówki opieki zdrowotnej,
+"If you wish to override default accounts settings and configure the Income and Receivable accounts for Healthcare, you can do so here.","Jeśli chcesz zastąpić domyślne ustawienia kont i skonfigurować konta dochodów i należności dla służby zdrowia, możesz to zrobić tutaj.",
+Out Patient SMS alerts,Alerty SMS dla pacjenta,
+"If you want to send SMS alert on Patient Registration, you can enable this option. Similary, you can set up Out Patient SMS alerts for other functionalities in this section. Click ","Jeśli chcesz wysłać powiadomienie SMS o rejestracji pacjenta, możesz włączyć tę opcję. Podobnie, w tej sekcji możesz skonfigurować alerty SMS dla pacjentów wychodzących dla innych funkcji. Kliknij",
+Admission Order Details,Szczegóły zlecenia przyjęcia,
+Admission Ordered For,Wstęp zamówiony dla,
+Expected Length of Stay,Oczekiwana długość pobytu,
+Admission Service Unit Type,Typ jednostki obsługi przyjęcia,
+Healthcare Practitioner (Primary),Lekarz (główna),
+Healthcare Practitioner (Secondary),Lekarz (średnia),
+Admission Instruction,Instrukcja przyjęcia,
+Chief Complaint,Główny zarzut,
+Medications,Leki,
+Investigations,Dochodzenia,
+Discharge Detials,Absolutorium Detials,
+Discharge Ordered Date,Data zamówienia wypisu,
+Discharge Instructions,Instrukcje dotyczące absolutorium,
+Follow Up Date,Data kontynuacji,
+Discharge Notes,Notatki absolutorium,
+Processing Inpatient Discharge,Przetwarzanie wypisu z szpitala,
+Processing Patient Admission,Przetwarzanie przyjęcia pacjenta,
+Check-in time cannot be greater than the current time,Czas zameldowania nie może być dłuższy niż aktualny czas,
+Process Transfer,Przetwarzanie transferu,
+HLC-LAB-.YYYY.-,HLC-LAB-.YYYY.-,
+Expected Result Date,Oczekiwana data wyniku,
+Expected Result Time,Oczekiwany czas wyniku,
+Printed on,Nadrukowany na,
+Requesting Practitioner,Praktykant,
+Requesting Department,Dział składania wniosków,
+Employee (Lab Technician),Pracownik (technik laboratoryjny),
+Lab Technician Name,Nazwisko technika laboratoryjnego,
+Lab Technician Designation,Oznaczenie technika laboratoryjnego,
+Compound Test Result,Wynik testu złożonego,
+Organism Test Result,Wynik testu organizmu,
+Sensitivity Test Result,Wynik testu wrażliwości,
+Worksheet Print,Drukuj arkusz roboczy,
+Worksheet Instructions,Instrukcje arkusza roboczego,
+Result Legend Print,Wydruk legendy wyników,
+Print Position,Pozycja drukowania,
+Bottom,Dolny,
+Top,Top,
+Both,Obie,
+Result Legend,Legenda wyników,
+Lab Tests,Testy laboratoryjne,
+No Lab Tests found for the Patient {0},Nie znaleziono testów laboratoryjnych dla pacjenta {0},
+"Did not send SMS, missing patient mobile number or message content.","Nie wysłano SMS-a, brak numeru telefonu komórkowego pacjenta lub treści wiadomości.",
+No Lab Tests created,Nie utworzono testów laboratoryjnych,
+Creating Lab Tests...,Tworzenie testów laboratoryjnych ...,
+Lab Test Group Template,Szablon grupy testów laboratoryjnych,
+Add New Line,Dodaj nową linię,
+Secondary UOM,Druga jednostka miary,
+"<b>Single</b>: Results which require only a single input.\n<br>\n<b>Compound</b>: Results which require multiple event inputs.\n<br>\n<b>Descriptive</b>: Tests which have multiple result components with manual result entry.\n<br>\n<b>Grouped</b>: Test templates which are a group of other test templates.\n<br>\n<b>No Result</b>: Tests with no results, can be ordered and billed but no Lab Test will be created. e.g.. Sub Tests for Grouped results","<b>Pojedynczy</b> : wyniki wymagające tylko jednego wprowadzenia.<br> <b>Złożone</b> : wyniki wymagające wielu wejść zdarzeń.<br> <b>Opisowe</b> : testy, które mają wiele składników wyników z ręcznym wprowadzaniem wyników.<br> <b>Zgrupowane</b> : szablony testów, które są grupą innych szablonów testów.<br> <b>Brak wyników</b> : Testy bez wyników można zamówić i zafakturować, ale nie zostaną utworzone żadne testy laboratoryjne. na przykład. Testy podrzędne dla wyników zgrupowanych",
+"If unchecked, the item will not be available in Sales Invoices for billing but can be used in group test creation. ","Jeśli odznaczone, pozycja nie będzie dostępna na fakturach sprzedaży do fakturowania, ale może być używana do tworzenia testów grupowych.",
+Description ,Opis,
+Descriptive Test,Test opisowy,
+Group Tests,Testy grupowe,
+Instructions to be printed on the worksheet,Instrukcje do wydrukowania w arkuszu,
+"Information to help easily interpret the test report, will be printed as part of the Lab Test result.",Informacje ułatwiające interpretację raportu z testu zostaną wydrukowane jako część wyniku testu laboratoryjnego.,
+Normal Test Result,Normalny wynik testu,
+Secondary UOM Result,Dodatkowy wynik UOM,
+Italic,italski,
+Underline,Podkreślać,
+Organism,Organizm,
+Organism Test Item,Przedmiot badania organizmu,
+Colony Population,Populacja kolonii,
+Colony UOM,Colony UOM,
+Tobacco Consumption (Past),Zużycie tytoniu (w przeszłości),
+Tobacco Consumption (Present),Zużycie tytoniu (obecne),
+Alcohol Consumption (Past),Spożycie alkoholu (w przeszłości),
+Alcohol Consumption (Present),Spożycie alkoholu (obecne),
+Billing Item,Pozycja rozliczeniowa,
+Medical Codes,Kody medyczne,
+Clinical Procedures,Procedury kliniczne,
+Order Admission,Zamów wstęp,
+Scheduling Patient Admission,Planowanie przyjęcia pacjenta,
+Order Discharge,Zamów rozładunek,
+Sample Details,Przykładowe szczegóły,
+Collected On,Zebrano dnia,
+No. of prints,Liczba wydruków,
+Number of prints required for labelling the samples,Liczba odbitek wymaganych do oznakowania próbek,
+HLC-VTS-.YYYY.-,HLC-VTS-.YYYY.-,
+In Time,W samą porę,
+Out Time,Out Time,
+Payroll Cost Center,Centrum kosztów listy płac,
+Approvers,Osoby zatwierdzające,
+The first Approver in the list will be set as the default Approver.,Pierwsza osoba zatwierdzająca na liście zostanie ustawiona jako domyślna osoba zatwierdzająca.,
+Shift Request Approver,Zatwierdzający prośbę o zmianę,
+PAN Number,Numer PAN,
+Provident Fund Account,Konto funduszu rezerwowego,
+MICR Code,Kod MICR,
+Repay unclaimed amount from salary,Zwróć nieodebraną kwotę z wynagrodzenia,
+Deduction from salary,Odliczenie od wynagrodzenia,
+Expired Leaves,Wygasłe liście,
+Reference No,Nr referencyjny,
+Haircut percentage is the percentage difference between market value of the Loan Security and the value ascribed to that Loan Security when used as collateral for that loan.,"Procent redukcji wartości to różnica procentowa między wartością rynkową Papieru Wartościowego Kredytu a wartością przypisaną temu Papierowi Wartościowemu Kredytowemu, gdy jest stosowany jako zabezpieczenie tej pożyczki.",
+Loan To Value Ratio expresses the ratio of the loan amount to the value of the security pledged. A loan security shortfall will be triggered if this falls below the specified value for any loan ,"Wskaźnik kredytu do wartości jest stosunkiem kwoty kredytu do wartości zastawionego zabezpieczenia. Niedobór zabezpieczenia pożyczki zostanie wyzwolony, jeśli spadnie poniżej określonej wartości dla jakiejkolwiek pożyczki",
+If this is not checked the loan by default will be considered as a Demand Loan,"Jeśli opcja ta nie zostanie zaznaczona, pożyczka domyślnie zostanie uznana za pożyczkę na żądanie",
+This account is used for booking loan repayments from the borrower and also disbursing loans to the borrower,"To konto służy do księgowania spłat pożyczki od pożyczkobiorcy, a także do wypłaty pożyczki pożyczkobiorcy",
+This account is capital account which is used to allocate capital for loan disbursal account ,"Rachunek ten jest rachunkiem kapitałowym, który służy do alokacji kapitału na rachunek wypłat pożyczki",
+This account will be used for booking loan interest accruals,To konto będzie używane do księgowania narosłych odsetek od kredytu,
+This account will be used for booking penalties levied due to delayed repayments,To konto będzie wykorzystywane do księgowania kar pobieranych z powodu opóźnionych spłat,
+Variant BOM,Wariant BOM,
+Template Item,Element szablonu,
+Select template item,Wybierz element szablonu,
+Select variant item code for the template item {0},Wybierz kod pozycji wariantu dla elementu szablonu {0},
+Downtime Entry,Wejście na czas przestoju,
+DT-,DT-,
+Workstation / Machine,Stacja robocza / maszyna,
+Operator,Operator,
+In Mins,W min,
+Downtime Reason,Przyczyna przestoju,
+Stop Reason,Stop Reason,
+Excessive machine set up time,Zbyt długi czas konfiguracji maszyny,
+Unplanned machine maintenance,Nieplanowana konserwacja maszyny,
+On-machine press checks,Kontrola prasy na maszynie,
+Machine operator errors,Błędy operatora maszyny,
+Machine malfunction,Awaria maszyny,
+Electricity down,Brak prądu,
+Operation Row Number,Numer wiersza operacji,
+Operation {0} added multiple times in the work order {1},Operacja {0} dodana wiele razy w zleceniu pracy {1},
+"If ticked, multiple materials can be used for a single Work Order. This is useful if one or more time consuming products are being manufactured.","Jeśli zaznaczone, w jednym zleceniu pracy można użyć wielu materiałów. Jest to przydatne, jeśli wytwarzany jest jeden lub więcej czasochłonnych produktów.",
+Backflush Raw Materials,Surowce do płukania wstecznego,
+"The Stock Entry of type 'Manufacture' is known as backflush. Raw materials being consumed to manufacture finished goods is known as backflushing. <br><br> When creating Manufacture Entry, raw-material items are backflushed based on BOM of production item. If you want raw-material items to be backflushed based on Material Transfer entry made against that Work Order instead, then you can set it under this field.","Wpis magazynowy typu „Produkcja” jest znany jako przepłukiwanie wsteczne. Surowce zużywane do produkcji wyrobów gotowych nazywa się płukaniem wstecznym.<br><br> Podczas tworzenia wpisu produkcji, pozycje surowców są przepłukiwane wstecznie na podstawie BOM pozycji produkcyjnej. Jeśli chcesz, aby pozycje surowców były wypłukiwane wstecznie na podstawie wpisu przeniesienia materiału dokonanego w ramach tego zlecenia pracy, możesz ustawić go w tym polu.",
+Work In Progress Warehouse,Magazyn Work In Progress,
+This Warehouse will be auto-updated in the Work In Progress Warehouse field of Work Orders.,Ten magazyn będzie automatycznie aktualizowany w polu Work In Progress Warehouse w Work Orders.,
+Finished Goods Warehouse,Magazyn Wyrobów Gotowych,
+This Warehouse will be auto-updated in the Target Warehouse field of Work Order.,Ten magazyn zostanie automatycznie zaktualizowany w polu Magazyn docelowy zlecenia pracy.,
+"If ticked, the BOM cost will be automatically updated based on Valuation Rate / Price List Rate / last purchase rate of raw materials.","Jeśli zaznaczone, koszt BOM zostanie automatycznie zaktualizowany na podstawie kursu wyceny / kursu cennika / ostatniego kursu zakupu surowców.",
+Source Warehouses (Optional),Magazyny źródłowe (opcjonalnie),
+"System will pickup the materials from the selected warehouses. If not specified, system will create material request for purchase.","System odbierze materiały z wybranych magazynów. Jeśli nie zostanie określony, system utworzy zapytanie o materiał do zakupu.",
+Lead Time,Czas oczekiwania,
+PAN Details,Szczegóły PAN,
+Create Customer,Utwórz klienta,
+Invoicing,Fakturowanie,
+Enable Auto Invoicing,Włącz automatyczne fakturowanie,
+Send Membership Acknowledgement,Wyślij potwierdzenie członkostwa,
+Send Invoice with Email,Wyślij fakturę e-mailem,
+Membership Print Format,Format wydruku członkostwa,
+Invoice Print Format,Format wydruku faktury,
+Revoke <Key></Key>,Unieważnić&lt;Key&gt;&lt;/Key&gt;,
+You can learn more about memberships in the manual. ,Więcej informacji na temat członkostwa można znaleźć w instrukcji.,
+ERPNext Docs,Dokumenty ERPNext,
+Regenerate Webhook Secret,Zregeneruj sekret Webhooka,
+Generate Webhook Secret,Wygeneruj klucz Webhook,
+Copy Webhook URL,Skopiuj adres URL webhooka,
+Linked Item,Powiązany element,
+Is Recurring,Powtarza się,
+HRA Exemption,Zwolnienie z HRA,
+Monthly House Rent,Miesięczny czynsz za dom,
+Rented in Metro City,Wynajęte w Metro City,
+HRA as per Salary Structure,HRA zgodnie ze strukturą wynagrodzeń,
+Annual HRA Exemption,Coroczne zwolnienie z HRA,
+Monthly HRA Exemption,Miesięczne zwolnienie z HRA,
+House Rent Payment Amount,Kwota spłaty czynszu za dom,
+Rented From Date,Wypożyczone od daty,
+Rented To Date,Wypożyczone do dnia,
+Monthly Eligible Amount,Kwota kwalifikowana miesięcznie,
+Total Eligible HRA Exemption,Całkowite kwalifikujące się zwolnienie z HRA,
+Validating Employee Attendance...,Weryfikacja obecności pracowników ...,
+Submitting Salary Slips and creating Journal Entry...,Przesyłanie odcinków wynagrodzenia i tworzenie zapisów księgowych ...,
+Calculate Payroll Working Days Based On,Oblicz dni robocze listy płac na podstawie,
+Consider Unmarked Attendance As,Rozważ nieoznaczoną obecność jako,
+Fraction of Daily Salary for Half Day,Część dziennego wynagrodzenia za pół dnia,
+Component Type,Typ komponentu,
+Provident Fund,Fundusz emerytalny,
+Additional Provident Fund,Dodatkowy fundusz emerytalny,
+Provident Fund Loan,Pożyczka z funduszu emerytalnego,
+Professional Tax,Podatek zawodowy,
+Is Income Tax Component,Składnik podatku dochodowego,
+Component properties and references ,Właściwości i odniesienia komponentów,
+Additional Salary ,Dodatkowe wynagrodzenie,
+Unmarked days,Nieoznakowane dni,
+Absent Days,Nieobecne dni,
+Conditions and Formula variable and example,Warunki i zmienna formuły oraz przykład,
+Feedback By,Informacje zwrotne od,
+Manufacturing Section,Sekcja Produkcyjna,
+"By default, the Customer Name is set as per the Full Name entered. If you want Customers to be named by a ","Domyślnie nazwa klienta jest ustawiona zgodnie z wprowadzoną pełną nazwą. Jeśli chcesz, aby klienci byli nazwani przez",
+Configure the default Price List when creating a new Sales transaction. Item prices will be fetched from this Price List.,Skonfiguruj domyślny Cennik podczas tworzenia nowej transakcji sprzedaży. Ceny pozycji zostaną pobrane z tego Cennika.,
+"If this option is configured 'Yes', ERPNext will prevent you from creating a Sales Invoice or Delivery Note without creating a Sales Order first. This configuration can be overridden for a particular Customer by enabling the 'Allow Sales Invoice Creation Without Sales Order' checkbox in the Customer master.","Jeśli ta opcja jest skonfigurowana jako „Tak”, ERPNext uniemożliwi utworzenie faktury sprzedaży lub dokumentu dostawy bez wcześniejszego tworzenia zamówienia sprzedaży. Tę konfigurację można zastąpić dla konkretnego klienta, zaznaczając pole wyboru „Zezwalaj na tworzenie faktur sprzedaży bez zamówienia sprzedaży” w karcie głównej Klient.",
+"If this option is configured 'Yes', ERPNext will prevent you from creating a Sales Invoice without creating a Delivery Note first. This configuration can be overridden for a particular Customer by enabling the 'Allow Sales Invoice Creation Without Delivery Note' checkbox in the Customer master.","Jeśli ta opcja jest skonfigurowana jako `` Tak &#39;&#39;, ERPNext uniemożliwi utworzenie faktury sprzedaży bez uprzedniego utworzenia dowodu dostawy. Tę konfigurację można zastąpić dla konkretnego klienta, zaznaczając pole wyboru „Zezwalaj na tworzenie faktur sprzedaży bez dowodu dostawy” we wzorcu klienta.",
+Default Warehouse for Sales Return,Domyślny magazyn do zwrotu sprzedaży,
+Default In Transit Warehouse,Domyślnie w magazynie tranzytowym,
+Enable Perpetual Inventory For Non Stock Items,Włącz ciągłe zapasy dla pozycji nie będących na stanie,
+HRA Settings,Ustawienia HRA,
+Basic Component,Element podstawowy,
+HRA Component,Komponent HRA,
+Arrear Component,Składnik zaległości,
+Please enter the company name to confirm,"Wprowadź nazwę firmy, aby potwierdzić",
+Quotation Lost Reason Detail,Szczegóły dotyczące utraconego powodu oferty,
+Enable Variants,Włącz warianty,
+Save Quotations as Draft,Zapisz oferty jako wersję roboczą,
+MAT-DN-RET-.YYYY.-,MAT-DN-RET-.YYYY.-,
+Please Select a Customer,Wybierz klienta,
+Against Delivery Note Item,Za list przewozowy,
+Is Non GST ,Nie zawiera podatku GST,
+Image Description,Opis obrazu,
+Transfer Status,Status transferu,
+MAT-PR-RET-.YYYY.-,MAT-PR-RET-.YYYY.-,
+Track this Purchase Receipt against any Project,Śledź ten dowód zakupu w dowolnym projekcie,
+Please Select a Supplier,Wybierz dostawcę,
+Add to Transit,Dodaj do transportu publicznego,
+Set Basic Rate Manually,Ustaw ręcznie stawkę podstawową,
+"By default, the Item Name is set as per the Item Code entered. If you want Items to be named by a ","Domyślnie nazwa pozycji jest ustawiona zgodnie z wprowadzonym kodem pozycji. Jeśli chcesz, aby elementy miały nazwę",
+Set a Default Warehouse for Inventory Transactions. This will be fetched into the Default Warehouse in the Item master.,Ustaw domyślny magazyn dla transakcji magazynowych. Zostanie to przeniesione do domyślnego magazynu w głównym module.,
+"This will allow stock items to be displayed in negative values. Using this option depends on your use case. With this option unchecked, the system warns before obstructing a transaction that is causing negative stock.","Umożliwi to wyświetlanie pozycji magazynowych w wartościach ujemnych. Korzystanie z tej opcji zależy od przypadku użycia. Gdy ta opcja jest odznaczona, system ostrzega przed zablokowaniem transakcji powodującej ujemny stan zapasów.",
+Choose between FIFO and Moving Average Valuation Methods. Click ,Wybierz metodę wyceny FIFO i ruchomą średnią wycenę. Kliknij,
+ to know more about them.,aby dowiedzieć się o nich więcej.,
+Show 'Scan Barcode' field above every child table to insert Items with ease.,"Pokaż pole „Skanuj kod kreskowy” nad każdą tabelą podrzędną, aby z łatwością wstawiać elementy.",
+"Serial numbers for stock will be set automatically based on the Items entered based on first in first out in transactions like Purchase/Sales Invoices, Delivery Notes, etc.","Numery seryjne dla zapasów zostaną ustawione automatycznie na podstawie pozycji wprowadzonych w oparciu o pierwsze weszło pierwsze wyszło w transakcjach, takich jak faktury zakupu / sprzedaży, dowody dostawy itp.",
+"If blank, parent Warehouse Account or company default will be considered in transactions","Jeśli puste, nadrzędne konto magazynu lub wartość domyślna firmy będą brane pod uwagę w transakcjach",
+Service Level Agreement Details,Szczegóły umowy dotyczącej poziomu usług,
+Service Level Agreement Status,Status umowy dotyczącej poziomu usług,
+On Hold Since,Wstrzymane od,
+Total Hold Time,Całkowity czas wstrzymania,
+Response Details,Szczegóły odpowiedzi,
+Average Response Time,Średni czas odpowiedzi,
+User Resolution Time,Czas rozwiązania użytkownika,
+SLA is on hold since {0},Umowa SLA została wstrzymana od {0},
+Pause SLA On Status,Wstrzymaj status SLA,
+Pause SLA On,Wstrzymaj SLA,
+Greetings Section,Sekcja Pozdrowienia,
+Greeting Title,Tytuł powitania,
+Greeting Subtitle,Podtytuł powitania,
+Youtube ID,Identyfikator YouTube,
+Youtube Statistics,Statystyki YouTube,
+Views,Wyświetlenia,
+Dislikes,Nie lubi,
+Video Settings,Ustawienia wideo,
+Enable YouTube Tracking,Włącz śledzenie w YouTube,
+30 mins,30 minut,
+1 hr,1 godz,
+6 hrs,6 godz,
+Patient Progress,Postęp pacjenta,
+Targetted,Ukierunkowane,
+Score Obtained,Wynik uzyskany,
+Sessions,Sesje,
+Average Score,Średni wynik,
+Select Assessment Template,Wybierz szablon oceny,
+ out of ,poza,
+Select Assessment Parameter,Wybierz parametr oceny,
+Gender: ,Płeć:,
+Contact: ,Kontakt:,
+Total Therapy Sessions: ,Sesje terapeutyczne:,
+Monthly Therapy Sessions: ,Comiesięczne sesje terapeutyczne:,
+Patient Profile,Profil pacjenta,
+Point Of Sale,Punkt sprzedaży,
+Email sent successfully.,E-mail wysłany pomyślnie.,
+Search by invoice id or customer name,Wyszukaj według identyfikatora faktury lub nazwy klienta,
+Invoice Status,Status faktury,
+Filter by invoice status,Filtruj według statusu faktury,
+Select item group,Wybierz grupę towarów,
+No items found. Scan barcode again.,Nie znaleziono żadnych przedmiotów. Ponownie zeskanuj kod kreskowy.,
+"Search by customer name, phone, email.","Szukaj według nazwy klienta, telefonu, adresu e-mail.",
+Enter discount percentage.,Wpisz procent rabatu.,
+Discount cannot be greater than 100%,Rabat nie może być większy niż 100%,
+Enter customer's email,Wpisz adres e-mail klienta,
+Enter customer's phone number,Wpisz numer telefonu klienta,
+Customer contact updated successfully.,Kontakt z klientem został zaktualizowany pomyślnie.,
+Item will be removed since no serial / batch no selected.,"Pozycja zostanie usunięta, ponieważ nie wybrano numeru seryjnego / partii.",
+Discount (%),Zniżka (%),
+You cannot submit the order without payment.,Nie możesz złożyć zamówienia bez zapłaty.,
+You cannot submit empty order.,Nie możesz złożyć pustego zamówienia.,
+To Be Paid,Do zapłacenia,
+Create POS Opening Entry,Utwórz wpis otwarcia POS,
+Please add Mode of payments and opening balance details.,Proszę dodać tryb płatności i szczegóły bilansu otwarcia.,
+Toggle Recent Orders,Przełącz ostatnie zamówienia,
+Save as Draft,Zapisz jako szkic,
+You must add atleast one item to save it as draft.,"Musisz dodać co najmniej jeden element, aby zapisać go jako wersję roboczą.",
+There was an error saving the document.,Wystąpił błąd podczas zapisywania dokumentu.,
+You must select a customer before adding an item.,Przed dodaniem pozycji musisz wybrać klienta.,
+Please Select a Company,Wybierz firmę,
+Active Leads,Aktywni leady,
+Please Select a Company.,Wybierz firmę.,
+BOM Operations Time,Czas operacji BOM,
+BOM ID,ID BOM,
+BOM Item Code,Kod pozycji BOM,
+Time (In Mins),Czas (w minutach),
+Sub-assembly BOM Count,Liczba BOM podzespołów,
+View Type,Typ widoku,
+Total Delivered Amount,Całkowita dostarczona kwota,
+Downtime Analysis,Analiza przestojów,
+Machine,Maszyna,
+Downtime (In Hours),Przestój (w godzinach),
+Employee Analytics,Analizy pracowników,
+"""From date"" can not be greater than or equal to ""To date""",„Data od” nie może być większa niż lub równa „Do dnia”,
+Exponential Smoothing Forecasting,Prognozowanie wygładzania wykładniczego,
+First Response Time for Issues,Czas pierwszej reakcji na problemy,
+First Response Time for Opportunity,Czas pierwszej reakcji na okazję,
+Depreciatied Amount,Kwota umorzona,
+Period Based On,Okres oparty na,
+Date Based On,Data na podstawie,
+{0} and {1} are mandatory,{0} i {1} są obowiązkowe,
+Consider Accounting Dimensions,Rozważ wymiary księgowe,
+Income Tax Deductions,Potrącenia podatku dochodowego,
+Income Tax Component,Składnik podatku dochodowego,
+Income Tax Amount,Kwota podatku dochodowego,
+Reserved Quantity for Production,Zarezerwowana ilość do produkcji,
+Projected Quantity,Prognozowana ilość,
+ Total Sales Amount,Całkowita kwota sprzedaży,
+Job Card Summary,Podsumowanie karty pracy,
+Id,ID,
+Time Required (In Mins),Wymagany czas (w minutach),
+From Posting Date,Od daty księgowania,
+To Posting Date,Do daty wysłania,
+No records found,Nic nie znaleziono,
+Customer/Lead Name,Nazwa klienta / potencjalnego klienta,
+Unmarked Days,Nieoznaczone dni,
+Jan,Jan,
+Feb,Luty,
+Mar,Zniszczyć,
+Apr,Kwi,
+Aug,Sie,
+Sep,Wrz,
+Oct,Paź,
+Nov,Lis,
+Dec,Dec,
+Summarized View,Podsumowanie,
+Production Planning Report,Raport planowania produkcji,
+Order Qty,Zamówiona ilość,
+Raw Material Code,Kod surowca,
+Raw Material Name,Nazwa surowca,
+Allotted Qty,Przydzielona ilość,
+Expected Arrival Date,Oczekiwana data przyjazdu,
+Arrival Quantity,Ilość przybycia,
+Raw Material Warehouse,Magazyn surowców,
+Order By,Zamów przez,
+Include Sub-assembly Raw Materials,Uwzględnij surowce podzespołów,
+Professional Tax Deductions,Profesjonalne potrącenia podatkowe,
+Program wise Fee Collection,Programowe pobieranie opłat,
+Fees Collected,Pobrane opłaty,
+Project Summary,Podsumowanie projektu,
+Total Tasks,Całkowita liczba zadań,
+Tasks Completed,Zadania zakończone,
+Tasks Overdue,Zadania zaległe,
+Completion,Ukończenie,
+Provident Fund Deductions,Potrącenia z funduszu rezerwowego,
+Purchase Order Analysis,Analiza zamówienia,
+From and To Dates are required.,Wymagane są daty od i do.,
+To Date cannot be before From Date.,Data do nie może być wcześniejsza niż data początkowa.,
+Qty to Bill,Ilość do rachunku,
+Group by Purchase Order,Grupuj według zamówienia,
+ Purchase Value,Wartość zakupu,
+Total Received Amount,Całkowita otrzymana kwota,
+Quality Inspection Summary,Podsumowanie kontroli jakości,
+ Quoted Amount,Kwota podana,
+Lead Time (Days),Czas realizacji (dni),
+Include Expired,Uwzględnij wygasły,
+Recruitment Analytics,Analizy rekrutacyjne,
+Applicant name,Nazwa wnioskodawcy,
+Job Offer status,Status oferty pracy,
+On Date,Na randkę,
+Requested Items to Order and Receive,Żądane pozycje do zamówienia i odbioru,
+Salary Payments Based On Payment Mode,Płatności wynagrodzeń w zależności od trybu płatności,
+Salary Payments via ECS,Wypłaty wynagrodzenia za pośrednictwem ECS,
+Account No,Nr konta,
+IFSC,IFSC,
+MICR,MICR,
+Sales Order Analysis,Analiza zleceń sprzedaży,
+Amount Delivered,Dostarczona kwota,
+Delay (in Days),Opóźnienie (w dniach),
+Group by Sales Order,Grupuj według zamówienia sprzedaży,
+ Sales Value,Wartość sprzedaży,
+Stock Qty vs Serial No Count,Ilość w magazynie a numer seryjny,
+Serial No Count,Numer seryjny,
+Work Order Summary,Podsumowanie zlecenia pracy,
+Produce Qty,Wyprodukuj ilość,
+Lead Time (in mins),Czas realizacji (w minutach),
+Charts Based On,Wykresy na podstawie,
+YouTube Interactions,Interakcje w YouTube,
+Published Date,Data publikacji,
+Barnch,Barnch,
+Select a Company,Wybierz firmę,
+Opportunity {0} created,Możliwość {0} została utworzona,
+Kindly select the company first,Najpierw wybierz firmę,
+Please enter From Date and To Date to generate JSON,"Wprowadź datę początkową i datę końcową, aby wygenerować JSON",
+PF Account,Konto PF,
+PF Amount,Kwota PF,
+Additional PF,Dodatkowe PF,
+PF Loan,Pożyczka PF,
+Download DATEV File,Pobierz plik DATEV,
+Numero has not set in the XML file,Numero nie ustawił w pliku XML,
+Inward Supplies(liable to reverse charge),Dostawy przychodzące (podlegające odwrotnemu obciążeniu),
+This is based on the course schedules of this Instructor,Jest to oparte na harmonogramach kursów tego instruktora,
+Course and Assessment,Kurs i ocena,
+Course {0} has been added to all the selected programs successfully.,Kurs {0} został pomyślnie dodany do wszystkich wybranych programów.,
+Programs updated,Programy zaktualizowane,
+Program and Course,Program i kurs,
+{0} or {1} is mandatory,{0} lub {1} jest obowiązkowe,
+Mandatory Fields,Pola obowiązkowe,
+Student {0}: {1} does not belong to Student Group {2},Student {0}: {1} nie należy do grupy uczniów {2},
+Student Attendance record {0} already exists against the Student {1},Rekord frekwencji {0} dla ucznia {1} już istnieje,
+Duplicate Entry,Zduplikowana wartość,
+Course and Fee,Kurs i opłata,
+Not eligible for the admission in this program as per Date Of Birth,Nie kwalifikuje się do przyjęcia w tym programie według daty urodzenia,
+Topic {0} has been added to all the selected courses successfully.,Temat {0} został pomyślnie dodany do wszystkich wybranych kursów.,
+Courses updated,Kursy zostały zaktualizowane,
+{0} {1} has been added to all the selected topics successfully.,Temat {0} {1} został pomyślnie dodany do wszystkich wybranych tematów.,
+Topics updated,Zaktualizowano tematy,
+Academic Term and Program,Okres akademicki i program,
+Please remove this item and try to submit again or update the posting time.,Usuń ten element i spróbuj przesłać go ponownie lub zaktualizuj czas publikacji.,
+Failed to Authenticate the API key.,Nie udało się uwierzytelnić klucza API.,
+Invalid Credentials,Nieprawidłowe dane logowania,
+URL can only be a string,URL może być tylko ciągiem,
+"Here is your webhook secret, this will be shown to you only once.","Oto Twój sekret webhooka, zostanie on pokazany tylko raz.",
+The payment for this membership is not paid. To generate invoice fill the payment details,Opłata za to członkostwo nie jest opłacana. Aby wygenerować fakturę wypełnij szczegóły płatności,
+An invoice is already linked to this document,Faktura jest już połączona z tym dokumentem,
+No customer linked to member {},Żaden klient nie jest powiązany z członkiem {},
+You need to set <b>Debit Account</b> in Membership Settings,Musisz ustawić <b>konto debetowe</b> w ustawieniach członkostwa,
+You need to set <b>Default Company</b> for invoicing in Membership Settings,Musisz ustawić <b>domyślną firmę</b> do fakturowania w ustawieniach członkostwa,
+You need to enable <b>Send Acknowledge Email</b> in Membership Settings,Musisz włączyć <b>wysyłanie wiadomości e-mail z potwierdzeniem</b> w ustawieniach członkostwa,
+Error creating membership entry for {0},Błąd podczas tworzenia wpisu członkowskiego dla {0},
+A customer is already linked to this Member,Klient jest już powiązany z tym członkiem,
+End Date must not be lesser than Start Date,Data zakończenia nie może być wcześniejsza niż data rozpoczęcia,
+Employee {0} already has Active Shift {1}: {2},Pracownik {0} ma już aktywną zmianę {1}: {2},
+ from {0},od {0},
+ to {0},do {0},
+Please select Employee first.,Najpierw wybierz pracownika.,
+Please set {0} for the Employee or for Department: {1},Ustaw {0} dla pracownika lub działu: {1},
+To Date should be greater than From Date,Data do powinna być większa niż Data początkowa,
+Employee Onboarding: {0} is already for Job Applicant: {1},Dołączanie pracowników: {0} jest już dla kandydatów o pracę: {1},
+Job Offer: {0} is already for Job Applicant: {1},Oferta pracy: {0} jest już dla osoby ubiegającej się o pracę: {1},
+Only Shift Request with status 'Approved' and 'Rejected' can be submitted,Można przesłać tylko żądanie zmiany ze statusem „Zatwierdzono” i „Odrzucono”,
+Shift Assignment: {0} created for Employee: {1},Przydział zmiany: {0} utworzony dla pracownika: {1},
+You can not request for your Default Shift: {0},Nie możesz zażądać zmiany domyślnej: {0},
+Only Approvers can Approve this Request.,Tylko osoby zatwierdzające mogą zatwierdzić tę prośbę.,
+Asset Value Analytics,Analiza wartości aktywów,
+Category-wise Asset Value,Wartość aktywów według kategorii,
+Total Assets,Aktywa ogółem,
+New Assets (This Year),Nowe zasoby (w tym roku),
+Row #{}: Depreciation Posting Date should not be equal to Available for Use Date.,Wiersz nr {}: Data księgowania amortyzacji nie powinna być równa dacie dostępności do użycia.,
+Incorrect Date,Nieprawidłowa data,
+Invalid Gross Purchase Amount,Nieprawidłowa kwota zakupu brutto,
+There are active maintenance or repairs against the asset. You must complete all of them before cancelling the asset.,Aktywna konserwacja lub naprawy są aktywne. Musisz je wszystkie wypełnić przed anulowaniem zasobu.,
+% Complete,% Ukończone,
+Back to Course,Powrót do kursu,
+Finish Topic,Zakończ temat,
+Mins,Min,
+by,przez,
+Back to,Wrócić do,
+Enrolling...,Rejestracja ...,
+You have successfully enrolled for the program ,Z powodzeniem zapisałeś się do programu,
+Enrolled,Zarejestrowany,
+Watch Intro,Obejrzyj wprowadzenie,
+We're here to help!,"Jesteśmy tutaj, aby pomóc!",
+Frequently Read Articles,Często czytane artykuły,
+Please set a default company address,Ustaw domyślny adres firmy,
+{0} is not a valid state! Check for typos or enter the ISO code for your state.,"{0} nie jest prawidłowym stanem! Sprawdź, czy nie ma literówek lub wprowadź kod ISO swojego stanu.",
+Error occured while parsing Chart of Accounts: Please make sure that no two accounts have the same name,"Wystąpił błąd podczas analizowania planu kont: upewnij się, że żadne dwa konta nie mają tej samej nazwy",
+Plaid invalid request error,Błąd żądania nieprawidłowego kratki,
+Please check your Plaid client ID and secret values,Sprawdź identyfikator klienta Plaid i tajne wartości,
+Bank transaction creation error,Błąd tworzenia transakcji bankowej,
+Unit of Measurement,Jednostka miary,
+Fiscal Year {0} Does Not Exist,Rok podatkowy {0} nie istnieje,
+Row # {0}: Returned Item {1} does not exist in {2} {3},Wiersz nr {0}: zwrócona pozycja {1} nie istnieje w {2} {3},
+Valuation type charges can not be marked as Inclusive,Opłaty związane z rodzajem wyceny nie mogą być oznaczone jako zawierające,
+You do not have permissions to {} items in a {}.,Nie masz uprawnień do {} elementów w {}.,
+Insufficient Permissions,Niewystarczające uprawnienia,
+You are not allowed to update as per the conditions set in {} Workflow.,Nie możesz aktualizować zgodnie z warunkami określonymi w {} Przepływie pracy.,
+Expense Account Missing,Brak konta wydatków,
+{0} is not a valid Value for Attribute {1} of Item {2}.,{0} nie jest prawidłową wartością atrybutu {1} elementu {2}.,
+Invalid Value,Niewłaściwa wartość,
+The value {0} is already assigned to an existing Item {1}.,Wartość {0} jest już przypisana do istniejącego elementu {1}.,
+"To still proceed with editing this Attribute Value, enable {0} in Item Variant Settings.","Aby nadal edytować tę wartość atrybutu, włącz opcję {0} w ustawieniach wariantu elementu.",
+Edit Not Allowed,Edycja niedozwolona,
+Row #{0}: Item {1} is already fully received in Purchase Order {2},Wiersz nr {0}: pozycja {1} jest już w całości otrzymana w zamówieniu {2},
+You cannot create or cancel any accounting entries with in the closed Accounting Period {0},Nie można tworzyć ani anulować żadnych zapisów księgowych w zamkniętym okresie rozliczeniowym {0},
+POS Invoice should have {} field checked.,Faktura POS powinna mieć zaznaczone pole {}.,
+Invalid Item,Nieprawidłowy przedmiot,
+Row #{}: You cannot add postive quantities in a return invoice. Please remove item {} to complete the return.,"Wiersz nr {}: nie można dodać ilości dodatnich do faktury zwrotnej. Usuń przedmiot {}, aby dokończyć zwrot.",
+The selected change account {} doesn't belongs to Company {}.,Wybrane konto zmiany {} nie należy do firmy {}.,
+Atleast one invoice has to be selected.,Należy wybrać przynajmniej jedną fakturę.,
+Payment methods are mandatory. Please add at least one payment method.,Metody płatności są obowiązkowe. Dodaj co najmniej jedną metodę płatności.,
+Please select a default mode of payment,Wybierz domyślny sposób płatności,
+You can only select one mode of payment as default,Możesz wybrać tylko jeden sposób płatności jako domyślny,
+Missing Account,Brakujące konto,
+Customers not selected.,Klienci nie wybrani.,
+Statement of Accounts,Wyciąg z konta,
+Ageing Report Based On ,Raport dotyczący starzenia na podstawie,
+Please enter distributed cost center,Wprowadź rozproszone centrum kosztów,
+Total percentage allocation for distributed cost center should be equal to 100,Całkowita alokacja procentowa dla rozproszonego centrum kosztów powinna wynosić 100,
+Cannot enable Distributed Cost Center for a Cost Center already allocated in another Distributed Cost Center,Nie można włączyć rozproszonego miejsca powstawania kosztów dla centrum kosztów już przydzielonego w innym rozproszonym miejscu kosztów,
+Parent Cost Center cannot be added in Distributed Cost Center,Nadrzędnego miejsca powstawania kosztów nie można dodać do rozproszonego miejsca powstawania kosztów,
+A Distributed Cost Center cannot be added in the Distributed Cost Center allocation table.,Nie można dodać Distributed Cost Center do tabeli alokacji Distributed Cost Center.,
+Cost Center with enabled distributed cost center can not be converted to group,Centrum kosztów z włączonym rozproszonym centrum kosztów nie może zostać przekonwertowane na grupę,
+Cost Center Already Allocated in a Distributed Cost Center cannot be converted to group,Centrum kosztów już alokowane w rozproszonym miejscu powstawania kosztów nie może zostać przekonwertowane na grupę,
+Trial Period Start date cannot be after Subscription Start Date,Data rozpoczęcia okresu próbnego nie może być późniejsza niż data rozpoczęcia subskrypcji,
+Subscription End Date must be after {0} as per the subscription plan,Data zakończenia subskrypcji musi przypadać po {0} zgodnie z planem subskrypcji,
+Subscription End Date is mandatory to follow calendar months,"Data zakończenia subskrypcji jest obowiązkowa, aby przestrzegać miesięcy kalendarzowych",
+Row #{}: POS Invoice {} is not against customer {},Wiersz nr {}: faktura POS {} nie jest skierowana przeciwko klientowi {},
+Row #{}: POS Invoice {} is not submitted yet,Wiersz nr {}: faktura POS {} nie została jeszcze przesłana,
+Row #{}: POS Invoice {} has been {},Wiersz nr {}: faktura POS {} została {},
+No Supplier found for Inter Company Transactions which represents company {0},Nie znaleziono dostawcy dla transakcji międzyfirmowych reprezentującego firmę {0},
+No Customer found for Inter Company Transactions which represents company {0},Nie znaleziono klienta dla transakcji międzyfirmowych reprezentującego firmę {0},
+Invalid Period,Nieprawidłowy okres,
+Selected POS Opening Entry should be open.,Wybrane wejście otwierające POS powinno być otwarte.,
+Invalid Opening Entry,Nieprawidłowy wpis otwierający,
+Please set a Company,Ustaw firmę,
+"Sorry, this coupon code's validity has not started","Przepraszamy, ważność tego kodu kuponu jeszcze się nie rozpoczęła",
+"Sorry, this coupon code's validity has expired","Przepraszamy, ważność tego kuponu wygasła",
+"Sorry, this coupon code is no longer valid","Przepraszamy, ten kod kuponu nie jest już ważny",
+For the 'Apply Rule On Other' condition the field {0} is mandatory,W przypadku warunku „Zastosuj regułę do innej” pole {0} jest obowiązkowe,
+{1} Not in Stock,{1} Niedostępny,
+Only {0} in Stock for item {1},Tylko {0} w magazynie dla produktu {1},
+Please enter a coupon code,Wprowadź kod kuponu,
+Please enter a valid coupon code,Wpisz prawidłowy kod kuponu,
+Invalid Child Procedure,Nieprawidłowa procedura podrzędna,
+Import Italian Supplier Invoice.,Import włoskiej faktury dostawcy.,
+"Valuation Rate for the Item {0}, is required to do accounting entries for {1} {2}.",Stawka wyceny dla przedmiotu {0} jest wymagana do zapisów księgowych dla {1} {2}.,
+ Here are the options to proceed:,"Oto opcje, aby kontynuować:",
+"If the item is transacting as a Zero Valuation Rate item in this entry, please enable 'Allow Zero Valuation Rate' in the {0} Item table.","Jeśli przedmiot jest przedmiotem transakcji jako pozycja z zerową wartością wyceny w tym wpisie, włącz opcję „Zezwalaj na zerową stawkę wyceny” w {0} tabeli pozycji.",
+"If not, you can Cancel / Submit this entry ","Jeśli nie, możesz anulować / przesłać ten wpis",
+ performing either one below:,wykonując jedną z poniższych czynności:,
+Create an incoming stock transaction for the Item.,Utwórz przychodzącą transakcję magazynową dla towaru.,
+Mention Valuation Rate in the Item master.,W głównym elemencie przedmiotu należy wspomnieć o współczynniku wyceny.,
+Valuation Rate Missing,Brak kursu wyceny,
+Serial Nos Required,Wymagane numery seryjne,
+Quantity Mismatch,Niedopasowanie ilości,
+"Please Restock Items and Update the Pick List to continue. To discontinue, cancel the Pick List.","Uzupełnij pozycje i zaktualizuj listę wyboru, aby kontynuować. Aby przerwać, anuluj listę wyboru.",
+Out of Stock,Obecnie brak na stanie,
+{0} units of Item {1} is not available.,{0} jednostki produktu {1} nie są dostępne.,
+Item for row {0} does not match Material Request,Pozycja w wierszu {0} nie pasuje do żądania materiału,
+Warehouse for row {0} does not match Material Request,Magazyn dla wiersza {0} nie jest zgodny z żądaniem materiałowym,
+Accounting Entry for Service,Wpis księgowy za usługę,
+All items have already been Invoiced/Returned,Wszystkie pozycje zostały już zafakturowane / zwrócone,
+All these items have already been Invoiced/Returned,Wszystkie te pozycje zostały już zafakturowane / zwrócone,
+Stock Reconciliations,Uzgodnienia zapasów,
+Merge not allowed,Scalanie niedozwolone,
+The following deleted attributes exist in Variants but not in the Template. You can either delete the Variants or keep the attribute(s) in template.,"Następujące usunięte atrybuty istnieją w wariantach, ale nie istnieją w szablonie. Możesz usunąć warianty lub zachować atrybut (y) w szablonie.",
+Variant Items,Elementy wariantowe,
+Variant Attribute Error,Błąd atrybutu wariantu,
+The serial no {0} does not belong to item {1},Numer seryjny {0} nie należy do produktu {1},
+There is no batch found against the {0}: {1},Nie znaleziono partii dla {0}: {1},
+Completed Operation,Operacja zakończona,
+Work Order Analysis,Analiza zlecenia pracy,
+Quality Inspection Analysis,Analiza kontroli jakości,
+Pending Work Order,Oczekujące zlecenie pracy,
+Last Month Downtime Analysis,Analiza przestojów w zeszłym miesiącu,
+Work Order Qty Analysis,Analiza ilości zleceń,
+Job Card Analysis,Analiza karty pracy,
+Monthly Total Work Orders,Miesięczne zamówienia łącznie,
+Monthly Completed Work Orders,Wykonane co miesiąc zamówienia,
+Ongoing Job Cards,Karty trwającej pracy,
+Monthly Quality Inspections,Comiesięczne kontrole jakości,
+(Forecast),(Prognoza),
+Total Demand (Past Data),Całkowity popyt (poprzednie dane),
+Total Forecast (Past Data),Prognoza całkowita (dane z przeszłości),
+Total Forecast (Future Data),Prognoza całkowita (dane przyszłe),
+Based On Document,Na podstawie dokumentu,
+Based On Data ( in years ),Na podstawie danych (w latach),
+Smoothing Constant,Stała wygładzania,
+Please fill the Sales Orders table,Prosimy o wypełnienie tabeli Zamówienia sprzedaży,
+Sales Orders Required,Wymagane zamówienia sprzedaży,
+Please fill the Material Requests table,Proszę wypełnić tabelę zamówień materiałowych,
+Material Requests Required,Wymagane żądania materiałów,
+Items to Manufacture are required to pull the Raw Materials associated with it.,Przedmioty do produkcji są zobowiązane do ściągnięcia związanych z nimi surowców.,
+Items Required,Wymagane elementy,
+Operation {0} does not belong to the work order {1},Operacja {0} nie należy do zlecenia pracy {1},
+Print UOM after Quantity,Drukuj UOM po Quantity,
+Set default {0} account for perpetual inventory for non stock items,Ustaw domyślne konto {0} dla ciągłych zapasów dla pozycji spoza magazynu,
+Loan Security {0} added multiple times,Bezpieczeństwo pożyczki {0} zostało dodane wiele razy,
+Loan Securities with different LTV ratio cannot be pledged against one loan,Dłużne Papiery Wartościowe o różnym wskaźniku LTV nie mogą być przedmiotem zastawu na jedną pożyczkę,
+Qty or Amount is mandatory for loan security!,Ilość lub kwota jest obowiązkowa dla zabezpieczenia kredytu!,
+Only submittted unpledge requests can be approved,Zatwierdzać można tylko przesłane żądania niezwiązane z próbą,
+Interest Amount or Principal Amount is mandatory,Kwota odsetek lub kwota główna jest obowiązkowa,
+Disbursed Amount cannot be greater than {0},Wypłacona kwota nie może być większa niż {0},
+Row {0}: Loan Security {1} added multiple times,Wiersz {0}: Bezpieczeństwo pożyczki {1} został dodany wiele razy,
+Row #{0}: Child Item should not be a Product Bundle. Please remove Item {1} and Save,Wiersz nr {0}: Element podrzędny nie powinien być pakietem produktów. Usuń element {1} i zapisz,
+Credit limit reached for customer {0},Osiągnięto limit kredytowy dla klienta {0},
+Could not auto create Customer due to the following missing mandatory field(s):,Nie można automatycznie utworzyć klienta z powodu następujących brakujących pól obowiązkowych:,
+Please create Customer from Lead {0}.,Utwórz klienta z potencjalnego klienta {0}.,
+Mandatory Missing,Obowiązkowy brak,
+Please set Payroll based on in Payroll settings,Ustaw listę płac na podstawie w ustawieniach listy płac,
+Additional Salary: {0} already exist for Salary Component: {1} for period {2} and {3},Dodatkowe wynagrodzenie: {0} już istnieje dla składnika wynagrodzenia: {1} za okres {2} i {3},
+From Date can not be greater than To Date.,Data początkowa nie może być większa niż data początkowa.,
+Payroll date can not be less than employee's joining date.,Data wypłaty nie może być wcześniejsza niż data przystąpienia pracownika.,
+From date can not be less than employee's joining date.,Data początkowa nie może być wcześniejsza niż data przystąpienia pracownika.,
+To date can not be greater than employee's relieving date.,Do tej pory nie może być późniejsza niż data zwolnienia pracownika.,
+Payroll date can not be greater than employee's relieving date.,Data wypłaty nie może być późniejsza niż data zwolnienia pracownika.,
+Row #{0}: Please enter the result value for {1},Wiersz nr {0}: wprowadź wartość wyniku dla {1},
+Mandatory Results,Obowiązkowe wyniki,
+Sales Invoice or Patient Encounter is required to create Lab Tests,Do tworzenia testów laboratoryjnych wymagana jest faktura sprzedaży lub spotkanie z pacjentami,
+Insufficient Data,Niedostateczna ilość danych,
+Lab Test(s) {0} created successfully,Test (y) laboratoryjne {0} zostały utworzone pomyślnie,
+Test :,Test:,
+Sample Collection {0} has been created,Utworzono zbiór próbek {0},
+Normal Range: ,Normalny zakres:,
+Row #{0}: Check Out datetime cannot be less than Check In datetime,Wiersz nr {0}: Data i godzina wyewidencjonowania nie może być mniejsza niż data i godzina wyewidencjonowania,
+"Missing required details, did not create Inpatient Record","Brak wymaganych szczegółów, nie utworzono rekordu pacjenta",
+Unbilled Invoices,Niezafakturowane faktury,
+Standard Selling Rate should be greater than zero.,Standardowa cena sprzedaży powinna być większa niż zero.,
+Conversion Factor is mandatory,Współczynnik konwersji jest obowiązkowy,
+Row #{0}: Conversion Factor is mandatory,Wiersz nr {0}: współczynnik konwersji jest obowiązkowy,
+Sample Quantity cannot be negative or 0,Ilość próbki nie może być ujemna ani 0,
+Invalid Quantity,Nieprawidłowa ilość,
+"Please set defaults for Customer Group, Territory and Selling Price List in Selling Settings","Ustaw wartości domyślne dla grupy klientów, terytorium i cennika sprzedaży w Ustawieniach sprzedaży",
+{0} on {1},{0} na {1},
+{0} with {1},{0} z {1},
+Appointment Confirmation Message Not Sent,Wiadomość z potwierdzeniem spotkania nie została wysłana,
+"SMS not sent, please check SMS Settings","SMS nie został wysłany, sprawdź ustawienia SMS",
+Healthcare Service Unit Type cannot have both {0} and {1},Typ jednostki usług opieki zdrowotnej nie może mieć jednocześnie {0} i {1},
+Healthcare Service Unit Type must allow atleast one among {0} and {1},Typ jednostki usług opieki zdrowotnej musi dopuszczać co najmniej jedną spośród {0} i {1},
+Set Response Time and Resolution Time for Priority {0} in row {1}.,Ustaw czas odpowiedzi i czas rozwiązania dla priorytetu {0} w wierszu {1}.,
+Response Time for {0} priority in row {1} can't be greater than Resolution Time.,Czas odpowiedzi dla {0} priorytetu w wierszu {1} nie może być dłuższy niż czas rozwiązania.,
+{0} is not enabled in {1},{0} nie jest włączony w {1},
+Group by Material Request,Grupuj według żądania materiału,
+Email Sent to Supplier {0},Wiadomość e-mail wysłana do dostawcy {0},
+"The Access to Request for Quotation From Portal is Disabled. To Allow Access, Enable it in Portal Settings.","Dostęp do zapytania ofertowego z portalu jest wyłączony. Aby zezwolić na dostęp, włącz go w ustawieniach portalu.",
+Supplier Quotation {0} Created,Oferta dostawcy {0} została utworzona,
+Valid till Date cannot be before Transaction Date,Data ważności do nie może być wcześniejsza niż data transakcji,
+Unlink Advance Payment on Cancellation of Order,Odłącz przedpłatę przy anulowaniu zamówienia,
+"Simple Python Expression, Example: territory != 'All Territories'","Proste wyrażenie w Pythonie, przykład: terytorium! = &#39;Wszystkie terytoria&#39;",
+Sales Contributions and Incentives,Składki na sprzedaż i zachęty,
+Sourced by Supplier,Źródło: Dostawca,
+Total weightage assigned should be 100%.<br>It is {0},Łączna przypisana waga powinna wynosić 100%.<br> To jest {0},
+Account {0} exists in parent company {1}.,Konto {0} istnieje w firmie macierzystej {1}.,
+"To overrule this, enable '{0}' in company {1}","Aby to zmienić, włącz „{0}” w firmie {1}",
+Invalid condition expression,Nieprawidłowe wyrażenie warunku,
+Please Select a Company First,Najpierw wybierz firmę,
+Please Select Both Company and Party Type First,Najpierw wybierz firmę i typ strony,
+Provide the invoice portion in percent,Podaj część faktury w procentach,
+Give number of days according to prior selection,Podaj liczbę dni według wcześniejszego wyboru,
+Email Details,Szczegóły wiadomości e-mail,
+"Select a greeting for the receiver. E.g. Mr., Ms., etc.","Wybierz powitanie dla odbiorcy. Np. Pan, Pani itp.",
+Preview Email,Podgląd wiadomości e-mail,
+Please select a Supplier,Wybierz dostawcę,
+Supplier Lead Time (days),Czas oczekiwania dostawcy (dni),
+"Home, Work, etc.","Dom, praca itp.",
+Exit Interview Held On,Zakończ rozmowę kwalifikacyjną wstrzymaną,
+Condition and formula,Stan i formuła,
+Sets 'Target Warehouse' in each row of the Items table.,Ustawia „Magazyn docelowy” w każdym wierszu tabeli Towary.,
+Sets 'Source Warehouse' in each row of the Items table.,Ustawia „Magazyn źródłowy” w każdym wierszu tabeli Towary.,
+POS Register,Rejestr POS,
+"Can not filter based on POS Profile, if grouped by POS Profile","Nie można filtrować na podstawie profilu POS, jeśli są pogrupowane według profilu POS",
+"Can not filter based on Customer, if grouped by Customer","Nie można filtrować na podstawie klienta, jeśli jest pogrupowany według klienta",
+"Can not filter based on Cashier, if grouped by Cashier","Nie można filtrować na podstawie Kasjera, jeśli jest pogrupowane według Kasjera",
+Payment Method,Metoda płatności,
+"Can not filter based on Payment Method, if grouped by Payment Method","Nie można filtrować na podstawie metody płatności, jeśli są pogrupowane według metody płatności",
+Supplier Quotation Comparison,Porównanie ofert dostawców,
+Price per Unit (Stock UOM),Cena za jednostkę (JM z magazynu),
+Group by Supplier,Grupuj według dostawcy,
+Group by Item,Grupuj według pozycji,
+Remember to set {field_label}. It is required by {regulation}.,"Pamiętaj, aby ustawić {field_label}. Jest to wymagane przez {przepis}.",
+Enrollment Date cannot be before the Start Date of the Academic Year {0},Data rejestracji nie może być wcześniejsza niż data rozpoczęcia roku akademickiego {0},
+Enrollment Date cannot be after the End Date of the Academic Term {0},Data rejestracji nie może być późniejsza niż data zakończenia okresu akademickiego {0},
+Enrollment Date cannot be before the Start Date of the Academic Term {0},Data rejestracji nie może być wcześniejsza niż data rozpoczęcia semestru akademickiego {0},
+Future Posting Not Allowed,Niedozwolone publikowanie w przyszłości,
+"To enable Capital Work in Progress Accounting, ","Aby włączyć księgowość produkcji w toku,",
+you must select Capital Work in Progress Account in accounts table,w tabeli kont należy wybrać Rachunek kapitałowy w toku,
+You can also set default CWIP account in Company {},Możesz także ustawić domyślne konto CWIP w firmie {},
+The Request for Quotation can be accessed by clicking on the following button,"Dostęp do zapytania ofertowego można uzyskać, klikając poniższy przycisk",
+Regards,pozdrowienia,
+Please click on the following button to set your new password,"Kliknij poniższy przycisk, aby ustawić nowe hasło",
+Update Password,Aktualizować hasło,
+Row #{}: Selling rate for item {} is lower than its {}. Selling {} should be atleast {},Wiersz nr {}: współczynnik sprzedaży dla przedmiotu {} jest niższy niż jego {}. Sprzedawanie {} powinno wynosić co najmniej {},
+You can alternatively disable selling price validation in {} to bypass this validation.,"Alternatywnie możesz wyłączyć weryfikację ceny sprzedaży w {}, aby ominąć tę weryfikację.",
+Invalid Selling Price,Nieprawidłowa cena sprzedaży,
+Address needs to be linked to a Company. Please add a row for Company in the Links table.,Adres musi być powiązany z firmą. Dodaj wiersz Firma w tabeli Łącza.,
+Company Not Linked,Firma niepowiązana,
+Import Chart of Accounts from CSV / Excel files,Importuj plan kont z plików CSV / Excel,
+Completed Qty cannot be greater than 'Qty to Manufacture',Ukończona ilość nie może być większa niż „Ilość do wyprodukowania”,
+"Row {0}: For Supplier {1}, Email Address is Required to send an email",Wiersz {0}: W przypadku dostawcy {1} do wysłania wiadomości e-mail wymagany jest adres e-mail,
+"If enabled, the system will post accounting entries for inventory automatically","Jeśli jest włączona, system automatycznie zaksięguje zapisy księgowe dotyczące zapasów",
+Accounts Frozen Till Date,Konta zamrożone do daty,
+Accounting entries are frozen up to this date. Nobody can create or modify entries except users with the role specified below,Do tej daty zapisy księgowe są zamrożone. Nikt nie może tworzyć ani modyfikować wpisów z wyjątkiem użytkowników z rolą określoną poniżej,
+Role Allowed to Set Frozen Accounts and Edit Frozen Entries,Rola dozwolona do ustawiania zamrożonych kont i edycji zamrożonych wpisów,
+Address used to determine Tax Category in transactions,Adres używany do określenia kategorii podatku w transakcjach,
+"The percentage you are allowed to bill more against the amount ordered. For example, if the order value is $100 for an item and tolerance is set as 10%, then you are allowed to bill up to $110 ","Procent, w jakim możesz zwiększyć rachunek od zamówionej kwoty. Na przykład, jeśli wartość zamówienia wynosi 100 USD za towar, a tolerancja jest ustawiona na 10%, możesz wystawić rachunek do 110 USD",
+This role is allowed to submit transactions that exceed credit limits,Ta rola umożliwia zgłaszanie transakcji przekraczających limity kredytowe,
+"If ""Months"" is selected, a fixed amount will be booked as deferred revenue or expense for each month irrespective of the number of days in a month. It will be prorated if deferred revenue or expense is not booked for an entire month","Jeśli zostanie wybrana opcja „Miesiące”, stała kwota zostanie zaksięgowana jako odroczone przychody lub wydatki dla każdego miesiąca, niezależnie od liczby dni w miesiącu. Zostanie naliczona proporcjonalnie, jeśli odroczone przychody lub wydatki nie zostaną zaksięgowane na cały miesiąc",
+"If this is unchecked, direct GL entries will be created to book deferred revenue or expense","Jeśli ta opcja nie jest zaznaczona, zostaną utworzone bezpośrednie wpisy GL w celu zaksięgowania odroczonych przychodów lub kosztów",
+Show Inclusive Tax in Print,Pokaż podatek wliczony w cenę w druku,
+Only select this if you have set up the Cash Flow Mapper documents,"Wybierz tę opcję tylko wtedy, gdy skonfigurowałeś dokumenty Cash Flow Mapper",
+Payment Channel,Kanał płatności,
+Is Purchase Order Required for Purchase Invoice & Receipt Creation?,Czy do wystawienia faktury i paragonu zakupu wymagane jest zamówienie zakupu?,
+Is Purchase Receipt Required for Purchase Invoice Creation?,Czy do utworzenia faktury zakupu jest wymagany dowód zakupu?,
+Maintain Same Rate Throughout the Purchase Cycle,Utrzymuj tę samą stawkę w całym cyklu zakupu,
+Allow Item To Be Added Multiple Times in a Transaction,Zezwalaj na wielokrotne dodawanie przedmiotu w transakcji,
+Suppliers,Dostawcy,
+Send Emails to Suppliers,Wyślij e-maile do dostawców,
+Select a Supplier,Wybierz dostawcę,
+Cannot mark attendance for future dates.,Nie można oznaczyć obecności na przyszłe daty.,
+Do you want to update attendance? <br> Present: {0} <br> Absent: {1},Czy chcesz zaktualizować frekwencję?<br> Obecnie: {0}<br> Nieobecny: {1},
+Mpesa Settings,Ustawienia Mpesa,
+Initiator Name,Nazwa inicjatora,
+Till Number,Do numeru,
+Sandbox,Piaskownica,
+ Online PassKey,Online PassKey,
+Security Credential,Poświadczenie bezpieczeństwa,
+Get Account Balance,Sprawdź saldo konta,
+Please set the initiator name and the security credential,Ustaw nazwę inicjatora i poświadczenia bezpieczeństwa,
+Inpatient Medication Entry,Wpis leków szpitalnych,
+HLC-IME-.YYYY.-,HLC-IME-.YYYY.-,
+Item Code (Drug),Kod pozycji (lek),
+Medication Orders,Zamówienia na lekarstwa,
+Get Pending Medication Orders,Uzyskaj oczekujące zamówienia na leki,
+Inpatient Medication Orders,Zamówienia na leki szpitalne,
+Medication Warehouse,Magazyn leków,
+Warehouse from where medication stock should be consumed,"Magazyn, z którego należy skonsumować zapasy leków",
+Fetching Pending Medication Orders,Pobieranie oczekujących zamówień na leki,
+Inpatient Medication Entry Detail,Szczegóły dotyczące przyjmowania leków szpitalnych,
+Medication Details,Szczegóły leków,
+Drug Code,Kod leku,
+Drug Name,Nazwa leku,
+Against Inpatient Medication Order,Nakaz przeciwdziałania lekom szpitalnym,
+Against Inpatient Medication Order Entry,Wpis zamówienia przeciwko lekarstwom szpitalnym,
+Inpatient Medication Order,Zamówienie na leki szpitalne,
+HLC-IMO-.YYYY.-,HLC-IMO-.YYYY.-,
+Total Orders,Całkowita liczba zamówień,
+Completed Orders,Zrealizowane zamówienia,
+Add Medication Orders,Dodaj zamówienia na leki,
+Adding Order Entries,Dodawanie wpisów zamówienia,
+{0} medication orders completed,Zrealizowano {0} zamówień na leki,
+{0} medication order completed,Zrealizowano {0} zamówienie na lek,
+Inpatient Medication Order Entry,Wpis zamówienia leków szpitalnych,
+Is Order Completed,Zamówienie zostało zrealizowane,
+Employee Records to Be Created By,Dokumentacja pracowników do utworzenia przez,
+Employee records are created using the selected field,Rekordy pracowników są tworzone przy użyciu wybranego pola,
+Don't send employee birthday reminders,Nie wysyłaj pracownikom przypomnień o urodzinach,
+Restrict Backdated Leave Applications,Ogranicz aplikacje urlopowe z datą wsteczną,
+Sequence ID,Identyfikator sekwencji,
+Sequence Id,Id. Sekwencji,
+Allow multiple material consumptions against a Work Order,Zezwalaj na wielokrotne zużycie materiałów w ramach zlecenia pracy,
+Plan time logs outside Workstation working hours,Planuj dzienniki czasu poza godzinami pracy stacji roboczej,
+Plan operations X days in advance,Planuj operacje z X-dniowym wyprzedzeniem,
+Time Between Operations (Mins),Czas między operacjami (min),
+Default: 10 mins,Domyślnie: 10 min,
+Overproduction for Sales and Work Order,Nadprodukcja dla sprzedaży i zlecenia pracy,
+"Update BOM cost automatically via scheduler, based on the latest Valuation Rate/Price List Rate/Last Purchase Rate of raw materials","Aktualizuj koszt BOM automatycznie za pomocą harmonogramu, na podstawie ostatniego kursu wyceny / kursu cennika / ostatniego kursu zakupu surowców",
+Purchase Order already created for all Sales Order items,Zamówienie zakupu zostało już utworzone dla wszystkich pozycji zamówienia sprzedaży,
+Select Items,Wybierz elementy,
+Against Default Supplier,Wobec domyślnego dostawcy,
+Auto close Opportunity after the no. of days mentioned above,Automatyczne zamknięcie Okazja po nr. dni wymienionych powyżej,
+Is Sales Order Required for Sales Invoice & Delivery Note Creation?,Czy do tworzenia faktur sprzedaży i dokumentów dostawy wymagane jest zamówienie sprzedaży?,
+Is Delivery Note Required for Sales Invoice Creation?,Czy do utworzenia faktury sprzedaży jest wymagany dowód dostawy?,
+How often should Project and Company be updated based on Sales Transactions?,Jak często należy aktualizować projekt i firmę na podstawie transakcji sprzedaży?,
+Allow User to Edit Price List Rate in Transactions,Pozwól użytkownikowi edytować stawkę cennika w transakcjach,
+Allow Item to Be Added Multiple Times in a Transaction,Zezwalaj na wielokrotne dodawanie przedmiotu w transakcji,
+Allow Multiple Sales Orders Against a Customer's Purchase Order,Zezwalaj na wiele zamówień sprzedaży w ramach zamówienia klienta,
+Validate Selling Price for Item Against Purchase Rate or Valuation Rate,Sprawdź cenę sprzedaży przedmiotu w stosunku do kursu zakupu lub kursu wyceny,
+Hide Customer's Tax ID from Sales Transactions,Ukryj identyfikator podatkowy klienta w transakcjach sprzedaży,
+"The 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.","Procent, jaki możesz otrzymać lub dostarczyć więcej w stosunku do zamówionej ilości. Na przykład, jeśli zamówiłeś 100 jednostek, a Twój dodatek wynosi 10%, możesz otrzymać 110 jednostek.",
+Action If Quality Inspection Is Not Submitted,"Działanie, jeśli kontrola jakości nie zostanie przesłana",
+Auto Insert Price List Rate If Missing,"Automatycznie wstaw stawkę cennika, jeśli brakuje",
+Automatically Set Serial Nos Based on FIFO,Automatycznie ustaw numery seryjne w oparciu o FIFO,
+Set Qty in Transactions Based on Serial No Input,Ustaw ilość w transakcjach na podstawie numeru seryjnego,
+Raise Material Request When Stock Reaches Re-order Level,"Podnieś żądanie materiałowe, gdy zapasy osiągną poziom ponownego zamówienia",
+Notify by Email on Creation of Automatic Material Request,Powiadamiaj e-mailem o utworzeniu automatycznego wniosku o materiał,
+Allow Material Transfer from Delivery Note to Sales Invoice,Zezwól na przeniesienie materiału z potwierdzenia dostawy do faktury sprzedaży,
+Allow Material Transfer from Purchase Receipt to Purchase Invoice,Zezwól na przeniesienie materiału z paragonu zakupu do faktury zakupu,
+Freeze Stocks Older Than (Days),Zatrzymaj zapasy starsze niż (dni),
+Role Allowed to Edit Frozen Stock,Rola uprawniona do edycji zamrożonych zapasów,
+The unallocated amount of Payment Entry {0} is greater than the Bank Transaction's unallocated amount,Nieprzydzielona kwota wpisu płatności {0} jest większa niż nieprzydzielona kwota transakcji bankowej,
+Payment Received,Otrzymano zapłatę,
+Attendance cannot be marked outside of Academic Year {0},Nie można oznaczyć obecności poza rokiem akademickim {0},
+Student is already enrolled via Course Enrollment {0},Student jest już zapisany za pośrednictwem rejestracji na kurs {0},
+Attendance cannot be marked for future dates.,Nie można zaznaczyć obecności na przyszłe daty.,
+Please add programs to enable admission application.,"Dodaj programy, aby włączyć aplikację o przyjęcie.",
+The following employees are currently still reporting to {0}:,Następujący pracownicy nadal podlegają obecnie {0}:,
+Please make sure the employees above report to another Active employee.,"Upewnij się, że powyżsi pracownicy zgłaszają się do innego aktywnego pracownika.",
+Cannot Relieve Employee,Nie można zwolnić pracownika,
+Please enter {0},Wprowadź {0},
+Please select another payment method. Mpesa does not support transactions in currency '{0}',Wybierz inną metodę płatności. MPesa nie obsługuje transakcji w walucie „{0}”,
+Transaction Error,Błąd transakcji,
+Mpesa Express Transaction Error,Błąd transakcji Mpesa Express,
+"Issue detected with Mpesa configuration, check the error logs for more details","Wykryto problem z konfiguracją Mpesa, sprawdź dzienniki błędów, aby uzyskać więcej informacji",
+Mpesa Express Error,Błąd Mpesa Express,
+Account Balance Processing Error,Błąd przetwarzania salda konta,
+Please check your configuration and try again,Sprawdź konfigurację i spróbuj ponownie,
+Mpesa Account Balance Processing Error,Błąd przetwarzania salda konta Mpesa,
+Balance Details,Szczegóły salda,
+Current Balance,Aktualne saldo,
+Available Balance,Dostępne saldo,
+Reserved Balance,Zarezerwowane saldo,
+Uncleared Balance,Nierówna równowaga,
+Payment related to {0} is not completed,Płatność związana z {0} nie została zakończona,
+Row #{}: Item Code: {} is not available under warehouse {}.,Wiersz nr {}: kod towaru: {} nie jest dostępny w magazynie {}.,
+Row #{}: Stock quantity not enough for Item Code: {} under warehouse {}. Available quantity {}.,Wiersz nr {}: Niewystarczająca ilość towaru dla kodu towaru: {} w magazynie {}. Dostępna Ilość {}.,
+Row #{}: Please select a serial no and batch against item: {} or remove it to complete transaction.,"Wiersz nr {}: Wybierz numer seryjny i partię dla towaru: {} lub usuń je, aby zakończyć transakcję.",
+Row #{}: No serial number selected against item: {}. Please select one or remove it to complete transaction.,"Wiersz nr {}: nie wybrano numeru seryjnego dla pozycji: {}. Wybierz jeden lub usuń go, aby zakończyć transakcję.",
+Row #{}: No batch selected against item: {}. Please select a batch or remove it to complete transaction.,"Wiersz nr {}: nie wybrano partii dla elementu: {}. Wybierz pakiet lub usuń go, aby zakończyć transakcję.",
+Payment amount cannot be less than or equal to 0,Kwota płatności nie może być mniejsza lub równa 0,
+Please enter the phone number first,Najpierw wprowadź numer telefonu,
+Row #{}: {} {} does not exist.,Wiersz nr {}: {} {} nie istnieje.,
+Row #{0}: {1} is required to create the Opening {2} Invoices,Wiersz nr {0}: {1} jest wymagany do utworzenia faktur otwarcia {2},
+You had {} errors while creating opening invoices. Check {} for more details,"Podczas otwierania faktur wystąpiło {} błędów. Sprawdź {}, aby uzyskać więcej informacji",
+Error Occured,Wystąpił błąd,
+Opening Invoice Creation In Progress,Otwieranie faktury w toku,
+Creating {} out of {} {},Tworzenie {} z {} {},
+(Serial No: {0}) cannot be consumed as it's reserverd to fullfill Sales Order {1}.,"(Nr seryjny: {0}) nie może zostać wykorzystany, ponieważ jest ponownie wysyłany w celu wypełnienia zamówienia sprzedaży {1}.",
+Item {0} {1},Przedmiot {0} {1},
+Last Stock Transaction for item {0} under warehouse {1} was on {2}.,Ostatnia transakcja magazynowa dotycząca towaru {0} w magazynie {1} miała miejsce w dniu {2}.,
+Stock Transactions for Item {0} under warehouse {1} cannot be posted before this time.,Transakcje magazynowe dla pozycji {0} w magazynie {1} nie mogą być księgowane przed tą godziną.,
+Posting future stock transactions are not allowed due to Immutable Ledger,Księgowanie przyszłych transakcji magazynowych nie jest dozwolone ze względu na niezmienną księgę,
+A BOM with name {0} already exists for item {1}.,Zestawienie komponentów o nazwie {0} już istnieje dla towaru {1}.,
+{0}{1} Did you rename the item? Please contact Administrator / Tech support,{0} {1} Czy zmieniłeś nazwę elementu? Skontaktuj się z administratorem / pomocą techniczną,
+At row #{0}: the sequence id {1} cannot be less than previous row sequence id {2},W wierszu {0}: identyfikator sekwencji {1} nie może być mniejszy niż identyfikator sekwencji poprzedniego wiersza {2},
+The {0} ({1}) must be equal to {2} ({3}),{0} ({1}) musi być równe {2} ({3}),
+"{0}, complete the operation {1} before the operation {2}.","{0}, zakończ operację {1} przed operacją {2}.",
+Cannot ensure delivery by Serial No as Item {0} is added with and without Ensure Delivery by Serial No.,"Nie można zapewnić dostawy według numeru seryjnego, ponieważ pozycja {0} jest dodawana zi bez opcji Zapewnij dostawę według numeru seryjnego.",
+Item {0} has no Serial No. Only serilialized items can have delivery based on Serial No,Przedmiot {0} nie ma numeru seryjnego. Tylko przesyłki seryjne mogą być dostarczane na podstawie numeru seryjnego,
+No active BOM found for item {0}. Delivery by Serial No cannot be ensured,Nie znaleziono aktywnego zestawienia komponentów dla pozycji {0}. Nie można zagwarantować dostawy według numeru seryjnego,
+No pending medication orders found for selected criteria,Nie znaleziono oczekujących zamówień na leki dla wybranych kryteriów,
+From Date cannot be after the current date.,Data początkowa nie może być późniejsza niż data bieżąca.,
+To Date cannot be after the current date.,Data końcowa nie może być późniejsza niż data bieżąca.,
+From Time cannot be after the current time.,Od godziny nie może być późniejsza niż aktualna godzina.,
+To Time cannot be after the current time.,To Time nie może być późniejsze niż aktualna godzina.,
+Stock Entry {0} created and ,Utworzono wpis giełdowy {0} i,
+Inpatient Medication Orders updated successfully,Zamówienia na leki szpitalne zostały pomyślnie zaktualizowane,
+Row {0}: Cannot create Inpatient Medication Entry against cancelled Inpatient Medication Order {1},Wiersz {0}: Cannot create the Inpatient Medication Entry for an incpatient medication Order {1},
+Row {0}: This Medication Order is already marked as completed,Wiersz {0}: to zamówienie na lek jest już oznaczone jako zrealizowane,
+Quantity not available for {0} in warehouse {1},Ilość niedostępna dla {0} w magazynie {1},
+Please enable Allow Negative Stock in Stock Settings or create Stock Entry to proceed.,"Włącz opcję Zezwalaj na ujemne zapasy w ustawieniach zapasów lub utwórz wpis zapasów, aby kontynuować.",
+No Inpatient Record found against patient {0},Nie znaleziono dokumentacji szpitalnej dotyczącej pacjenta {0},
+An Inpatient Medication Order {0} against Patient Encounter {1} already exists.,Istnieje już nakaz leczenia szpitalnego {0} przeciwko spotkaniu z pacjentami {1}.,
+Allow In Returns,Zezwalaj na zwroty,
+Hide Unavailable Items,Ukryj niedostępne elementy,
+Apply Discount on Discounted Rate,Zastosuj zniżkę na obniżoną stawkę,
+Therapy Plan Template,Szablon planu terapii,
+Fetching Template Details,Pobieranie szczegółów szablonu,
+Linked Item Details,Szczegóły połączonego elementu,
+Therapy Types,Rodzaje terapii,
+Therapy Plan Template Detail,Szczegóły szablonu planu terapii,
+Non Conformance,Niezgodność,
+Process Owner,Właściciel procesu,
+Corrective Action,Działania naprawcze,
+Preventive Action,Akcja prewencyjna,
+Problem,Problem,
+Responsible,Odpowiedzialny,
+Completion By,Zakończenie do,
+Process Owner Full Name,Imię i nazwisko właściciela procesu,
+Right Index,Prawy indeks,
+Left Index,Lewy indeks,
+Sub Procedure,Procedura podrzędna,
+Passed,Zdał,
+Print Receipt,Wydrukuj pokwitowanie,
+Edit Receipt,Edytuj rachunek,
+Focus on search input,Skoncentruj się na wyszukiwaniu,
+Focus on Item Group filter,Skoncentruj się na filtrze grupy przedmiotów,
+Checkout Order / Submit Order / New Order,Zamówienie do kasy / Prześlij zamówienie / Nowe zamówienie,
+Add Order Discount,Dodaj rabat na zamówienie,
+Item Code: {0} is not available under warehouse {1}.,Kod towaru: {0} nie jest dostępny w magazynie {1}.,
+Serial numbers unavailable for Item {0} under warehouse {1}. Please try changing warehouse.,Numery seryjne są niedostępne dla towaru {0} w magazynie {1}. Spróbuj zmienić magazyn.,
+Fetched only {0} available serial numbers.,Pobrano tylko {0} dostępnych numerów seryjnych.,
+Switch Between Payment Modes,Przełącz między trybami płatności,
+Enter {0} amount.,Wprowadź kwotę {0}.,
+You don't have enough points to redeem.,"Nie masz wystarczającej liczby punktów, aby je wymienić.",
+You can redeem upto {0}.,Możesz wykorzystać maksymalnie {0}.,
+Enter amount to be redeemed.,Wprowadź kwotę do wykupu.,
+You cannot redeem more than {0}.,Nie możesz wykorzystać więcej niż {0}.,
+Open Form View,Otwórz widok formularza,
+POS invoice {0} created succesfully,Faktura POS {0} została utworzona pomyślnie,
+Stock quantity not enough for Item Code: {0} under warehouse {1}. Available quantity {2}.,Za mało towaru dla kodu towaru: {0} w magazynie {1}. Dostępna ilość {2}.,
+Serial No: {0} has already been transacted into another POS Invoice.,Nr seryjny: {0} został już sprzedany na inną fakturę POS.,
+Balance Serial No,Nr seryjny wagi,
+Warehouse: {0} does not belong to {1},Magazyn: {0} nie należy do {1},
+Please select batches for batched item {0},Wybierz partie dla produktu wsadowego {0},
+Please select quantity on row {0},Wybierz ilość w wierszu {0},
+Please enter serial numbers for serialized item {0},Wprowadź numery seryjne dla towaru z numerem seryjnym {0},
+Batch {0} already selected.,Wiązka {0} już wybrana.,
+Please select a warehouse to get available quantities,"Wybierz magazyn, aby uzyskać dostępne ilości",
+"For transfer from source, selected quantity cannot be greater than available quantity",W przypadku transferu ze źródła wybrana ilość nie może być większa niż ilość dostępna,
+Cannot find Item with this Barcode,Nie można znaleźć przedmiotu z tym kodem kreskowym,
+{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2},{0} jest obowiązkowe. Być może rekord wymiany walut nie jest tworzony dla {1} do {2},
+{} has submitted assets linked to it. You need to cancel the assets to create purchase return.,"{} przesłał zasoby z nim powiązane. Musisz anulować zasoby, aby utworzyć zwrot zakupu.",
+Cannot cancel this document as it is linked with submitted asset {0}. Please cancel it to continue.,"Nie można anulować tego dokumentu, ponieważ jest on powiązany z przesłanym zasobem {0}. Anuluj, aby kontynuować.",
+Row #{}: Serial No. {} has already been transacted into another POS Invoice. Please select valid serial no.,Wiersz nr {}: Numer seryjny {} został już przetworzony na inną fakturę POS. Proszę wybrać prawidłowy numer seryjny.,
+Row #{}: Serial Nos. {} has already been transacted into another POS Invoice. Please select valid serial no.,Wiersz nr {}: numery seryjne {} zostały już przetworzone na inną fakturę POS. Proszę wybrać prawidłowy numer seryjny.,
+Item Unavailable,Pozycja niedostępna,
+Row #{}: Serial No {} cannot be returned since it was not transacted in original invoice {},"Wiersz nr {}: nr seryjny {} nie może zostać zwrócony, ponieważ nie był przedmiotem transakcji na oryginalnej fakturze {}",
+Please set default Cash or Bank account in Mode of Payment {},Ustaw domyślne konto gotówkowe lub bankowe w trybie płatności {},
+Please set default Cash or Bank account in Mode of Payments {},Ustaw domyślne konto gotówkowe lub bankowe w Trybie płatności {},
+Please ensure {} account is a Balance Sheet account. You can change the parent account to a Balance Sheet account or select a different account.,"Upewnij się, że konto {} jest kontem bilansowym. Możesz zmienić konto nadrzędne na konto bilansowe lub wybrać inne konto.",
+Please ensure {} account is a Payable account. Change the account type to Payable or select a different account.,"Upewnij się, że konto {} jest kontem płatnym. Zmień typ konta na Płatne lub wybierz inne konto.",
+Row {}: Expense Head changed to {} ,Wiersz {}: nagłówek wydatków zmieniony na {},
+because account {} is not linked to warehouse {} ,ponieważ konto {} nie jest połączone z magazynem {},
+or it is not the default inventory account,lub nie jest to domyślne konto magazynowe,
+Expense Head Changed,Zmiana głowy wydatków,
+because expense is booked against this account in Purchase Receipt {},ponieważ wydatek jest księgowany na tym koncie na dowodzie zakupu {},
+as no Purchase Receipt is created against Item {}. ,ponieważ dla przedmiotu {} nie jest tworzony dowód zakupu.,
+This is done to handle accounting for cases when Purchase Receipt is created after Purchase Invoice,"Ma to na celu obsługę księgowania przypadków, w których paragon zakupu jest tworzony po fakturze zakupu",
+Purchase Order Required for item {},Wymagane zamówienie zakupu dla produktu {},
+To submit the invoice without purchase order please set {} ,"Aby przesłać fakturę bez zamówienia, należy ustawić {}",
+as {} in {},jak w {},
+Mandatory Purchase Order,Obowiązkowe zamówienie zakupu,
+Purchase Receipt Required for item {},Potwierdzenie zakupu jest wymagane dla przedmiotu {},
+To submit the invoice without purchase receipt please set {} ,"Aby przesłać fakturę bez dowodu zakupu, ustaw {}",
+Mandatory Purchase Receipt,Obowiązkowy dowód zakupu,
+POS Profile {} does not belongs to company {},Profil POS {} nie należy do firmy {},
+User {} is disabled. Please select valid user/cashier,Użytkownik {} jest wyłączony. Wybierz prawidłowego użytkownika / kasjera,
+Row #{}: Original Invoice {} of return invoice {} is {}. ,Wiersz nr {}: Oryginalna faktura {} faktury zwrotnej {} to {}.,
+Original invoice should be consolidated before or along with the return invoice.,Oryginał faktury należy skonsolidować przed lub wraz z fakturą zwrotną.,
+You can add original invoice {} manually to proceed.,"Aby kontynuować, możesz ręcznie dodać oryginalną fakturę {}.",
+Please ensure {} account is a Balance Sheet account. ,"Upewnij się, że konto {} jest kontem bilansowym.",
+You can change the parent account to a Balance Sheet account or select a different account.,Możesz zmienić konto nadrzędne na konto bilansowe lub wybrać inne konto.,
+Please ensure {} account is a Receivable account. ,"Upewnij się, że konto {} jest kontem należnym.",
+Change the account type to Receivable or select a different account.,Zmień typ konta na Odbywalne lub wybierz inne konto.,
+{} can't be cancelled since the Loyalty Points earned has been redeemed. First cancel the {} No {},"Nie można anulować {}, ponieważ zebrane punkty lojalnościowe zostały wykorzystane. Najpierw anuluj {} Nie {}",
+already exists,już istnieje,
+POS Closing Entry {} against {} between selected period,Wejście zamknięcia POS {} względem {} między wybranym okresem,
+POS Invoice is {},Faktura POS to {},
+POS Profile doesn't matches {},Profil POS nie pasuje {},
+POS Invoice is not {},Faktura POS nie jest {},
+POS Invoice isn't created by user {},Faktura POS nie jest tworzona przez użytkownika {},
+Row #{}: {},Wiersz nr {}: {},
+Invalid POS Invoices,Nieprawidłowe faktury POS,
+Please add the account to root level Company - {},Dodaj konto do poziomu Firma - {},
+"While creating account for Child Company {0}, parent account {1} not found. Please create the parent account in corresponding COA",Podczas tworzenia konta dla firmy podrzędnej {0} nie znaleziono konta nadrzędnego {1}. Utwórz konto rodzica w odpowiednim certyfikacie autentyczności,
+Account Not Found,Konto nie znalezione,
+"While creating account for Child Company {0}, parent account {1} found as a ledger account.",Podczas tworzenia konta dla Firmy podrzędnej {0} konto nadrzędne {1} zostało uznane za konto księgowe.,
+Please convert the parent account in corresponding child company to a group account.,Zmień konto nadrzędne w odpowiedniej firmie podrzędnej na konto grupowe.,
+Invalid Parent Account,Nieprawidłowe konto nadrzędne,
+"Renaming it is only allowed via parent company {0}, to avoid mismatch.","Zmiana nazwy jest dozwolona tylko za pośrednictwem firmy macierzystej {0}, aby uniknąć niezgodności.",
+"If you {0} {1} quantities of the item {2}, the scheme {3} will be applied on the item.",W przypadku {0} {1} ilości towaru {2} schemat {3} zostanie zastosowany do towaru.,
+"If you {0} {1} worth item {2}, the scheme {3} will be applied on the item.","Jeśli {0} {1} cenisz przedmiot {2}, schemat {3} zostanie zastosowany do elementu.",
+"As the field {0} is enabled, the field {1} is mandatory.","Ponieważ pole {0} jest włączone, pole {1} jest obowiązkowe.",
+"As the field {0} is enabled, the value of the field {1} should be more than 1.","Ponieważ pole {0} jest włączone, wartość pola {1} powinna być większa niż 1.",
+Cannot deliver Serial No {0} of item {1} as it is reserved to fullfill Sales Order {2},"Nie można dostarczyć numeru seryjnego {0} elementu {1}, ponieważ jest on zarezerwowany do realizacji zamówienia sprzedaży {2}",
+"Sales Order {0} has reservation for the item {1}, you can only deliver reserved {1} against {0}.","Zamówienie sprzedaży {0} ma rezerwację na produkt {1}, możesz dostarczyć zarezerwowane tylko {1} w ramach {0}.",
+{0} Serial No {1} cannot be delivered,Nie można dostarczyć {0} numeru seryjnego {1},
+Row {0}: Subcontracted Item is mandatory for the raw material {1},Wiersz {0}: Pozycja podwykonawcza jest obowiązkowa dla surowca {1},
+"As there are sufficient raw materials, Material Request is not required for Warehouse {0}.","Ponieważ ilość surowców jest wystarczająca, żądanie materiałów nie jest wymagane dla magazynu {0}.",
+" If you still want to proceed, please enable {0}.","Jeśli nadal chcesz kontynuować, włącz {0}.",
+The item referenced by {0} - {1} is already invoiced,"Pozycja, do której odwołuje się {0} - {1}, została już zafakturowana",
+Therapy Session overlaps with {0},Sesja terapeutyczna pokrywa się z {0},
+Therapy Sessions Overlapping,Nakładanie się sesji terapeutycznych,
+Therapy Plans,Plany terapii,
+"Item Code, warehouse, quantity are required on row {0}","Kod pozycji, magazyn, ilość są wymagane w wierszu {0}",
+Get Items from Material Requests against this Supplier,Pobierz pozycje z żądań materiałowych od tego dostawcy,
+Enable European Access,Włącz dostęp w Europie,
+Creating Purchase Order ...,Tworzenie zamówienia zakupu ...,
+"Select a Supplier from the Default Suppliers of the items below. On selection, a Purchase Order will be made against items belonging to the selected Supplier only.","Wybierz dostawcę spośród domyślnych dostawców z poniższych pozycji. Po dokonaniu wyboru, Zamówienie zostanie złożone wyłącznie dla pozycji należących do wybranego Dostawcy.",
+Row #{}: You must select {} serial numbers for item {}.,Wiersz nr {}: należy wybrać {} numery seryjne dla towaru {}.,
diff --git a/erpnext/translations/quc.csv b/erpnext/translations/quc.csv
index 4493d2d..a69d23b 100644
--- a/erpnext/translations/quc.csv
+++ b/erpnext/translations/quc.csv
@@ -1,13 +1,13 @@
-apps/erpnext/erpnext/accounts/general_ledger.py,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Riq jun ajilib’al jechataj chupam re le nima wuj teq xa sach che le uk’exik
-DocType: Company,Create Chart Of Accounts Based On,Kujak uwach etal pa ri
-DocType: Program Enrollment Fee,Program Enrollment Fee,Rajil re utz’ib’axik pale cholb’al chak
-DocType: Employee Transfer,New Company,K’ak’ chakulib’al
-DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Utz re uk’ayixik le q’atoj le copanawi le ka loq’ik
-DocType: Opportunity,Opportunity Type,Uwach ramajil
-DocType: Fee Schedule,Fee Schedule,Cholb’al chak utojik jujunal
-DocType: Cheque Print Template,Cheque Width,Nim uxach uk’exwach pwaq
-apps/erpnext/erpnext/hr/doctype/employee/employee.js,Please enter Preferred Contact Email,Taquqxa’n kematz’ib’m uj’el
-DocType: Item,Supplier Items,Q’ataj che uyaik
-,Stock Ageing,Najtir k’oji’k
-apps/erpnext/erpnext/education/doctype/student/student.py,Date of Birth cannot be greater than today.,Ler q’ij k’ojik kumaj taj che le q’ij re kamik
-apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py,Transactions can only be deleted by the creator of the Company,Le uk’exik xaqxu’ kakiw uk’exik le b’anowik le chakulib’al
+Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Riq jun ajilib’al jechataj chupam re le nima wuj teq xa sach che le uk’exik,
+Create Chart Of Accounts Based On,Kujak uwach etal pa ri,
+Program Enrollment Fee,Rajil re utz’ib’axik pale cholb’al chak,
+New Company,K’ak’ chakulib’al,
+Validate Selling Price for Item against Purchase Rate or Valuation Rate,Utz re uk’ayixik le q’atoj le copanawi le ka loq’ik,
+Opportunity Type,Uwach ramajil,
+Fee Schedule,Cholb’al chak utojik jujunal,
+Cheque Width,Nim uxach uk’exwach pwaq,
+Please enter Preferred Contact Email,Taquqxa’n kematz’ib’m uj’el,
+Supplier Items,Q’ataj che uyaik,
+Stock Ageing,Najtir k’oji’k,
+Date of Birth cannot be greater than today.,Ler q’ij k’ojik kumaj taj che le q’ij re kamik,
+Transactions can only be deleted by the creator of the Company,Le uk’exik xaqxu’ kakiw uk’exik le b’anowik le chakulib’al,
diff --git a/erpnext/translations/ro.csv b/erpnext/translations/ro.csv
index 8f97d07..56a604c 100644
--- a/erpnext/translations/ro.csv
+++ b/erpnext/translations/ro.csv
@@ -1,9839 +1,9837 @@
-"""Customer Provided Item"" cannot be Purchase Item also","""Elementul furnizat de client"" nu poate fi și articolul de cumpărare",
-"""Customer Provided Item"" cannot have Valuation Rate","""Elementul furnizat de client"" nu poate avea rata de evaluare",
-"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","""Este activ fix"" nu poate fi debifată deoarece există informații împotriva produsului",
-'Based On' and 'Group By' can not be same,'Bazat pe' și 'Grupat dupa' nu pot fi identice,
-'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 pot fi vide,
-'From Date' is required,'Din Data' este necesar,
-'From Date' must be after 'To Date','Din Data' trebuie să fie dupã 'Până în Data',
-'Has Serial No' can not be 'Yes' for non-stock item,'Are numãr de serie' nu poate fi 'Da' pentru articolele care nu au stoc,
-'Opening',&quot;Deschiderea&quot;,
-'To Case No.' cannot be less than 'From Case No.','Până la situația nr.' nu poate fi mai mică decât 'De la situația nr.',
-'To Date' is required,'Până la data' este necesară,
-'Total',&#39;Total&#39;,
-'Update Stock' can not be checked because items are not delivered via {0},"""Actualizare stoc"" nu poate fi activat, deoarece obiectele nu sunt livrate prin {0}",
-'Update Stock' cannot be checked for fixed asset sale,&quot;Actualizare stoc&quot; nu poate fi verificată de vânzare de active fixe,
-) for {0},) pentru {0},
-1 exact match.,1 potrivire exactă.,
-90-Above,90-si mai mult,
-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 să redenumiți grupul de clienți,
-A Default Service Level Agreement already exists.,Există deja un Acord de nivel de serviciu implicit.,
-A Lead requires either a person's name or an organization's name,"Un conducător necesită fie numele unei persoane, fie numele unei organizații",
-A customer with the same name already exists,Un client cu același nume există deja,
-A question must have more than one options,O întrebare trebuie să aibă mai multe opțiuni,
-A qustion must have at least one correct options,O chestiune trebuie să aibă cel puțin o opțiune corectă,
-A {0} exists between {1} and {2} (,A {0} există între {1} și {2} (,
-A4,A4,
-API Endpoint,API Endpoint,
-API Key,Cheie API,
-Abbr can not be blank or space,Abr. nu poate fi gol sau spațiu,
-Abbreviation already used for another company,Abreviere deja folosita pentru o altă companie,
-Abbreviation cannot have more than 5 characters,Prescurtarea nu poate conține mai mult de 5 caractere,
-Abbreviation is mandatory,Abreviere este obligatorie,
-About the Company,Despre companie,
-About your company,Despre Compania ta,
-Above,Deasupra,
-Absent,Absent,
-Academic Term,Termen academic,
-Academic Term: ,Termen academic:,
-Academic Year,An academic,
-Academic Year: ,An academic:,
-Accepted + Rejected Qty must be equal to Received quantity for Item {0},Cant. acceptată + respinsă trebuie să fie egală cu cantitatea recepționată pentru articolul {0},
-Access Token,Acces Token,
-Accessable Value,Valoare accesibilă,
-Account,Cont,
-Account Number,Numar de cont,
-Account Number {0} already used in account {1},Numărul contului {0} deja utilizat în contul {1},
-Account Pay Only,Contul Plătiți numai,
-Account Type,Tipul Contului,
-Account Type for {0} must be {1},Tipul de cont pentru {0} trebuie să fie {1},
-"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Soldul contului este deja în credit, nu vă este permis să setați ""Balanța trebuie să fie"" drept ""Debit"".",
-"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Soldul contului este deja în credit, nu vă este permis să setați ""Balanța trebuie să fie"" drept ""Credit"".",
-Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Numărul contului pentru contul {0} nu este disponibil. <br> Vă rugăm să configurați corect planul de conturi.,
-Account with child nodes cannot be converted to ledger,Un cont cu noduri copil nu poate fi transformat în registru contabil,
-Account with child nodes cannot be set as ledger,Cont cu noduri copil nu poate fi setat ca Registru Contabil,
-Account with existing transaction can not be converted to group.,Un cont cu tranzacții existente nu poate fi transformat în grup.,
-Account with existing transaction can not be deleted,Un cont cu tranzacții existente nu poate fi șters,
-Account with existing transaction cannot be converted to ledger,Un cont cu tranzacții existente nu poate fi transformat în registru contabil,
-Account {0} does not belong to company: {1},Contul {0} nu aparține companiei: {1},
-Account {0} does not belongs to company {1},Contul {0} nu aparține companiei {1},
-Account {0} does not exist,Contul {0} nu există,
-Account {0} does not exists,Contul {0} nu există,
-Account {0} does not match with Company {1} in Mode of Account: {2},Contul {0} nu se potrivește cu Compania {1} în modul de cont: {2},
-Account {0} has been entered multiple times,Contul {0} a fost introdus de mai multe ori,
-Account {0} is added in the child company {1},Contul {0} este adăugat în compania copil {1},
-Account {0} is frozen,Contul {0} este Blocat,
-Account {0} is invalid. Account Currency must be {1},Contul {0} nu este valid. Valuta contului trebuie să fie {1},
-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 există,
-Account {0}: You can not assign itself as parent account,Contul {0}: nu puteți atribui contului în sine calitatea de cont părinte,
-Account: {0} can only be updated via Stock Transactions,Contul: {0} poate fi actualizat doar prin Tranzacții stoc,
-Account: {0} with currency: {1} can not be selected,Contul: {0} cu moneda: {1} nu poate fi selectat,
-Accountant,Contabil,
-Accounting,Contabilitate,
-Accounting Entry for Asset,Înregistrare contabilă a activelor,
-Accounting Entry for Stock,Intrare Contabilă pentru Stoc,
-Accounting Entry for {0}: {1} can only be made in currency: {2},Intrarea contabila pentru {0}: {1} se poate face numai în valuta: {2},
-Accounting Ledger,Registru Jurnal,
-Accounting journal entries.,Inregistrari contabile de jurnal.,
-Accounts,Conturi,
-Accounts Manager,Manager de Conturi,
-Accounts Payable,Conturi de plată,
-Accounts Payable Summary,Rezumat conturi pentru plăți,
-Accounts Receivable,Conturi de Incasare,
-Accounts Receivable Summary,Rezumat conturi de încasare,
-Accounts User,Conturi de utilizator,
-Accounts table cannot be blank.,Planul de conturi nu poate fi gol.,
-Accrual Journal Entry for salaries from {0} to {1},Înregistrarea jurnalelor de angajare pentru salariile de la {0} la {1},
-Accumulated Depreciation,Amortizarea cumulată,
-Accumulated Depreciation Amount,Sumă Amortizarea cumulată,
-Accumulated Depreciation as on,Amortizarea ca pe acumulat,
-Accumulated Monthly,lunar acumulat,
-Accumulated Values,Valorile acumulate,
-Accumulated Values in Group Company,Valori acumulate în compania grupului,
-Achieved ({}),Realizat ({}),
-Action,Acțiune:,
-Action Initialised,Acțiune inițiată,
-Actions,Acțiuni,
-Active,Activ,
-Activity Cost exists for Employee {0} against Activity Type - {1},Există cost activitate pentru angajatul {0} comparativ tipului de activitate - {1},
-Activity Cost per Employee,Cost activitate per angajat,
-Activity Type,Tip Activitate,
-Actual Cost,Costul actual,
-Actual Delivery Date,Data de livrare efectivă,
-Actual Qty,Cant. Efectivă,
-Actual Qty is mandatory,Cantitatea efectivă este obligatorie,
-Actual Qty {0} / Waiting Qty {1},Cant. reală {0} / Cant. în așteptare {1},
-Actual Qty: Quantity available in the warehouse.,Cantitate Actuală: Cantitate disponibilă în depozit.,
-Actual qty in stock,Cant. efectivă în stoc,
-Actual type tax cannot be included in Item rate in row {0},Taxa efectivă de tip nu poate fi inclusă în tariful articolului din rândul {0},
-Add,Adaugă,
-Add / Edit Prices,Adăugați / editați preturi,
-Add Comment,Adăugă Comentariu,
-Add Customers,Adăugați clienți,
-Add Employees,Adăugă Angajați,
-Add Item,Adăugă Element,
-Add Items,Adăugă Elemente,
-Add Leads,Adaugă Oportunități,
-Add Multiple Tasks,Adăugă Sarcini Multiple,
-Add Row,Adăugă Rând,
-Add Sales Partners,Adăugă Parteneri de Vânzări,
-Add Serial No,Adăugaţi Nr. de Serie,
-Add Students,Adăugă Elevi,
-Add Suppliers,Adăugă Furnizori,
-Add Time Slots,Adăugă Intervale de Timp,
-Add Timesheets,Adăugă Pontaje,
-Add Timeslots,Adăugă Intervale de Timp,
-Add Users to Marketplace,Adăugă Utilizatori la Marketplace,
-Add a new address,Adăugați o adresă nouă,
-Add cards or custom sections on homepage,Adăugați carduri sau secțiuni personalizate pe pagina principală,
-Add more items or open full form,Adăugă mai multe elemente sau deschide formular complet,
-Add notes,Adăugați note,
-Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,"Adăugați restul organizației dvs. ca utilizatori. Puteți, de asemenea, invita Clienții în portal prin adăugarea acestora din Contacte",
-Add to Details,Adăugă la Detalii,
-Add/Remove Recipients,Adăugaţi/Stergeţi Destinatari,
-Added,Adăugat,
-Added to details,Adăugat la detalii,
-Added {0} users,{0} utilizatori adăugați,
-Additional Salary Component Exists.,Există o componentă suplimentară a salariului.,
-Address,Adresă,
-Address Line 2,Adresă Linie 2,
-Address Name,Numele adresei,
-Address Title,Titlu adresă,
-Address Type,Tip adresă,
-Administrative Expenses,Cheltuieli administrative,
-Administrative Officer,Ofițer administrativ,
-Administrator,Administrator,
-Admission,Admitere,
-Admission and Enrollment,Admitere și înscriere,
-Admissions for {0},Admitere pentru {0},
-Admit,admite,
-Admitted,Admis,
-Advance Amount,Sumă în avans,
-Advance Payments,Plățile în avans,
-Advance account currency should be same as company currency {0},Advance valuta contului ar trebui să fie aceeași ca moneda companiei {0},
-Advance amount cannot be greater than {0} {1},Suma avans nu poate fi mai mare decât {0} {1},
-Advertising,Publicitate,
-Aerospace,Spaţiul aerian,
-Against,Comparativ,
-Against Account,Comparativ contului,
-Against Journal Entry {0} does not have any unmatched {1} entry,Comparativ intrării {0} în jurnal nu are nici o intrare nepotrivită {1},
-Against Journal Entry {0} is already adjusted against some other voucher,Comparativ intrării {0} în jurnal este deja ajustată comparativ altui voucher,
-Against Supplier Invoice {0} dated {1},Contra facturii furnizorului {0} din data {1},
-Against Voucher,Contra voucherului,
-Against Voucher Type,Contra tipului de voucher,
-Age,Vârstă,
-Age (Days),Vârsta (zile),
-Ageing Based On,Uzură bazată pe,
-Ageing Range 1,Clasă de uzură 1,
-Ageing Range 2,Clasă de uzură 2,
-Ageing Range 3,Clasă de uzură 3,
-Agriculture,Agricultură,
-Agriculture (beta),Agricultura (beta),
-Airline,linie aeriană,
-All Accounts,Toate conturile,
-All Addresses.,Toate adresele.,
-All Assessment Groups,Toate grupurile de evaluare,
-All BOMs,toate BOM,
-All Contacts.,Toate contactele.,
-All Customer Groups,Toate grupurile de clienți,
-All Day,Toată ziua,
-All Departments,Toate departamentele,
-All Healthcare Service Units,Toate unitățile de servicii medicale,
-All Item Groups,Toate grupurile articolului,
-All Jobs,Toate locurile de muncă,
-All Products,Toate produsele,
-All Products or Services.,Toate produsele sau serviciile.,
-All Student Admissions,Toate Admitere Student,
-All Supplier Groups,Toate grupurile de furnizori,
-All Supplier scorecards.,Toate cardurile de evaluare ale furnizorilor.,
-All Territories,Toate Teritoriile,
-All Warehouses,toate Depozite,
-All communications including and above this shall be moved into the new Issue,"Toate comunicările, inclusiv și deasupra acestora, vor fi mutate în noua ediție",
-All items have already been transferred for this Work Order.,Toate articolele au fost deja transferate pentru această comandă de lucru.,
-All other ITC,Toate celelalte ITC,
-All the mandatory Task for employee creation hasn't been done yet.,Toate sarcinile obligatorii pentru crearea de angajați nu au fost încă încheiate.,
-Allocate Payment Amount,Alocați suma de plată,
-Allocated Amount,Sumă alocată,
-Allocated Leaves,Frunzele alocate,
-Allocating leaves...,Alocarea frunzelor ...,
-Already record exists for the item {0},Încă există înregistrare pentru articolul {0},
-"Already set default in pos profile {0} for user {1}, kindly disabled default","Deja a fost setat implicit în profilul pos {0} pentru utilizatorul {1}, dezactivat în mod prestabilit",
-Alternate Item,Articol alternativ,
-Alternative item must not be same as item code,Elementul alternativ nu trebuie să fie identic cu cel al articolului,
-Amended From,Modificat din,
-Amount,Sumă,
-Amount After Depreciation,Suma după amortizare,
-Amount of Integrated Tax,Suma impozitului integrat,
-Amount of TDS Deducted,Cantitatea de TDS dedusă,
-Amount should not be less than zero.,Suma nu trebuie să fie mai mică de zero.,
-Amount to Bill,Sumă pentru facturare,
-Amount {0} {1} against {2} {3},Suma {0} {1} împotriva {2} {3},
-Amount {0} {1} deducted against {2},Suma {0} {1} dedusă împotriva {2},
-Amount {0} {1} transferred from {2} to {3},Suma {0} {1} transferată de la {2} la {3},
-Amount {0} {1} {2} {3},Suma {0} {1} {2} {3},
-Amt,Suma,
-"An Item Group exists with same name, please change the item name or rename the item group","Există un grup de articole cu aceeaşi denumire, vă rugăm să schimbați denumirea articolului sau să redenumiţi grupul articolului",
-An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Un termen academic cu acest &quot;An universitar&quot; {0} și &quot;Numele Termenul&quot; {1} există deja. Vă rugăm să modificați aceste intrări și încercați din nou.,
-An error occurred during the update process,A apărut o eroare în timpul procesului de actualizare,
-"An item exists with same name ({0}), please change the item group name or rename the item","Există un articol cu aceeaşi denumire ({0}), vă rugăm să schimbați denumirea grupului articolului sau să redenumiţi articolul",
-Analyst,Analist,
-Analytics,Google Analytics,
-Annual Billing: {0},Facturare anuală: {0},
-Annual Salary,Salariu anual,
-Anonymous,Anonim,
-Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},O altă înregistrare bugetară {0} există deja pentru {1} &#39;{2}&#39; și contul &#39;{3}&#39; pentru anul fiscal {4},
-Another Period Closing Entry {0} has been made after {1},O altă intrare închidere de perioada {0} a fost efectuată după {1},
-Another Sales Person {0} exists with the same Employee id,Un alt Sales Person {0} există cu același ID Angajat,
-Antibiotic,Antibiotic,
-Apparel & Accessories,Îmbrăcăminte și accesorii,
-Applicable For,Aplicabil pentru,
-"Applicable if the company is SpA, SApA or SRL","Se aplică dacă compania este SpA, SApA sau SRL",
-Applicable if the company is a limited liability company,Se aplică dacă compania este o societate cu răspundere limitată,
-Applicable if the company is an Individual or a Proprietorship,Se aplică dacă compania este o persoană fizică sau o proprietate,
-Applicant,Solicitant,
-Applicant Type,Tipul solicitantului,
-Application of Funds (Assets),Aplicarea fondurilor (active),
-Application period cannot be across two allocation records,Perioada de aplicare nu poate fi cuprinsă între două înregistrări de alocare,
-Application period cannot be outside leave allocation period,Perioada de aplicare nu poate fi perioadă de alocare concediu în afara,
-Applied,Aplicat,
-Apply Now,Aplica acum,
-Appointment Confirmation,Confirmare programare,
-Appointment Duration (mins),Durata intalnire (minute),
-Appointment Type,Tip de întâlnire,
-Appointment {0} and Sales Invoice {1} cancelled,Mențiunea {0} și factura de vânzări {1} au fost anulate,
-Appointments and Encounters,Numiri și întâlniri,
-Appointments and Patient Encounters,Numiri și întâlniri cu pacienții,
-Appraisal {0} created for Employee {1} in the given date range,Expertiza {0} creată pentru angajatul {1} în intervalul de timp dat,
-Apprentice,Începător,
-Approval Status,Status aprobare,
-Approval Status must be 'Approved' or 'Rejected',"Statusul aprobării trebuie să fie ""Aprobat"" sau ""Respins""",
-Approve,Aproba,
-Approving Role cannot be same as role the rule is Applicable To,Aprobarea unui rol nu poate fi aceeaşi cu rolul. Regula este aplicabilă pentru,
-Approving User cannot be same as user the rule is Applicable To,Aprobarea unui utilizator nu poate fi aceeași cu utilizatorul. Regula este aplicabilă pentru,
-"Apps using current key won't be able to access, are you sure?","Aplicațiile care utilizează cheia curentă nu vor putea accesa, sunteți sigur?",
-Are you sure you want to cancel this appointment?,Sigur doriți să anulați această întâlnire?,
-Arrear,restanță,
-As Examiner,Ca Examiner,
-As On Date,Ca pe data,
-As Supervisor,Ca supraveghetor,
-As per rules 42 & 43 of CGST Rules,Conform regulilor 42 și 43 din Regulile CGST,
-As per section 17(5),În conformitate cu secțiunea 17 (5),
-As per your assigned Salary Structure you cannot apply for benefits,"În conformitate cu structura salarială atribuită, nu puteți aplica pentru beneficii",
-Assessment,Evaluare,
-Assessment Criteria,Criterii de evaluare,
-Assessment Group,Grup de evaluare,
-Assessment Group: ,Grup de evaluare:,
-Assessment Plan,Plan de evaluare,
-Assessment Plan Name,Numele planului de evaluare,
-Assessment Report,Raport de evaluare,
-Assessment Reports,Rapoarte de evaluare,
-Assessment Result,Rezultatul evaluării,
-Assessment Result record {0} already exists.,Inregistrarea Rezultatului evaluării {0} există deja.,
-Asset,activ,
-Asset Category,Categorie activ,
-Asset Category is mandatory for Fixed Asset item,Categorie Activ este obligatorie pentru articolul Activ Fix,
-Asset Maintenance,Întreținerea activelor,
-Asset Movement,Miscarea activelor,
-Asset Movement record {0} created,Mișcarea de înregistrare a activelor {0} creat,
-Asset Name,Denumire activ,
-Asset Received But Not Billed,"Activul primit, dar nu facturat",
-Asset Value Adjustment,Ajustarea valorii activelor,
-"Asset cannot be cancelled, as it is already {0}","Activul nu poate fi anulat, deoarece este deja {0}",
-Asset scrapped via Journal Entry {0},Activ casate prin Jurnal de intrare {0},
-"Asset {0} cannot be scrapped, as it is already {1}","Activul {0} nu poate fi scos din uz, deoarece este deja {1}",
-Asset {0} does not belong to company {1},Activul {0} nu aparține companiei {1},
-Asset {0} must be submitted,Activul {0} trebuie transmis,
-Assets,Active,
-Assign,Atribuiţi,
-Assign Salary Structure,Alocați structurii salariale,
-Assign To,Atribuţi pentru,
-Assign to Employees,Atribuie la Angajați,
-Assigning Structures...,Alocarea structurilor ...,
-Associate,Asociaţi,
-At least one mode of payment is required for POS invoice.,Cel puțin un mod de plată este necesar factura POS.,
-Atleast one item should be entered with negative quantity in return document,Cel puțin un articol ar trebui să fie introdus cu cantitate negativa în documentul de returnare,
-Atleast one of the Selling or Buying must be selected,Cel puţin una din opţiunile de vânzare sau cumpărare trebuie să fie selectată,
-Atleast one warehouse is mandatory,Cel puţin un depozit este obligatoriu,
-Attach Logo,Atașați logo,
-Attachment,Atașament,
-Attachments,Ataşamente,
-Attendance,prezență,
-Attendance From Date and Attendance To Date is mandatory,Prezenţa de la data și Prezența până la data sunt obligatorii,
-Attendance can not be marked for future dates,Prezenţa nu poate fi consemnată pentru date viitoare,
-Attendance date can not be less than employee's joining date,Data de prezență nu poate fi anteriara datii angajarii salariatului,
-Attendance for employee {0} is already marked,Prezenţa pentru angajatul {0} este deja consemnată,
-Attendance for employee {0} is already marked for this day,Prezența pentru angajatul {0} este deja marcată pentru această zi,
-Attendance has been marked successfully.,Prezența a fost marcată cu succes.,
-Attendance not submitted for {0} as it is a Holiday.,Participarea nu a fost trimisă pentru {0} deoarece este o sărbătoare.,
-Attendance not submitted for {0} as {1} on leave.,Participarea nu a fost trimisă pentru {0} ca {1} în concediu.,
-Attribute table is mandatory,Tabelul atribut este obligatoriu,
-Attribute {0} selected multiple times in Attributes Table,Atributul {0} este selectat de mai multe ori în tabelul Atribute,
-Author,Autor,
-Authorized Signatory,Semnatar autorizat,
-Auto Material Requests Generated,Cereri materiale Auto Generat,
-Auto Repeat,Auto Repetare,
-Auto repeat document updated,Documentul repetat automat a fost actualizat,
-Automotive,Autopropulsat,
-Available,Disponibil,
-Available Leaves,Frunzele disponibile,
-Available Qty,Cantitate disponibilă,
-Available Selling,Vânzări disponibile,
-Available for use date is required,Data de utilizare disponibilă pentru utilizare este necesară,
-Available slots,Sloturi disponibile,
-Available {0},Disponibile {0},
-Available-for-use Date should be after purchase date,Data disponibilă pentru utilizare ar trebui să fie după data achiziției,
-Average Age,Varsta medie,
-Average Rate,Rata medie,
-Avg Daily Outgoing,Ieșire zilnică medie,
-Avg. Buying Price List Rate,Med. Achiziționarea ratei listei de prețuri,
-Avg. Selling Price List Rate,Med. Rata de listare a prețurilor de vânzare,
-Avg. Selling Rate,Rată Medie de Vânzare,
-BOM,BOM,
-BOM Browser,BOM Browser,
-BOM No,Nr. BOM,
-BOM Rate,Rata BOM,
-BOM Stock Report,BOM Raport stoc,
-BOM and Manufacturing Quantity are required,BOM și cantitatea de producție sunt necesare,
-BOM does not contain any stock item,BOM nu conține nici un element de stoc,
-BOM {0} does not belong to Item {1},BOM {0} nu aparţine articolului {1},
-BOM {0} must be active,BOM {0} trebuie să fie activ,
-BOM {0} must be submitted,BOM {0} trebuie să fie introdus,
-Balance,Bilanţ,
-Balance (Dr - Cr),Sold (Dr-Cr),
-Balance ({0}),Sold ({0}),
-Balance Qty,Cantitate de bilanţ,
-Balance Sheet,Bilanț,
-Balance Value,Valoarea bilanţului,
-Balance for Account {0} must always be {1},Bilanţă pentru contul {0} trebuie să fie întotdeauna {1},
-Bank,bancă,
-Bank Account,Cont bancar,
-Bank Accounts,Conturi bancare,
-Bank Draft,Ciorna bancară,
-Bank Entries,Intrările bancare,
-Bank Name,Denumire bancă,
-Bank Overdraft Account,Descoperire cont bancar,
-Bank Reconciliation,Reconciliere bancară,
-Bank Reconciliation Statement,Extras de cont reconciliere bancară,
-Bank Statement,Extras de cont,
-Bank Statement Settings,Setările declarației bancare,
-Bank Statement balance as per General Ledger,Banca echilibru Declarație pe General Ledger,
-Bank account cannot be named as {0},Contul bancar nu poate fi numit ca {0},
-Bank/Cash transactions against party or for internal transfer,tranzacții bancare / numerar contra partidului sau pentru transfer intern,
-Banking,Bancar,
-Banking and Payments,Bancare și plăți,
-Barcode {0} already used in Item {1},Cod de bare {0} deja folosit pentru articolul {1},
-Barcode {0} is not a valid {1} code,Codul de bare {0} nu este un cod valid {1},
-Base,Baza,
-Base URL,URL-ul de bază,
-Based On,Bazat pe,
-Based On Payment Terms,Pe baza condițiilor de plată,
-Basic,Elementar,
-Batch,Lot,
-Batch Entries,Înregistrări pe lot,
-Batch ID is mandatory,ID-ul lotului este obligatoriu,
-Batch Inventory,Lot Inventarul,
-Batch Name,Nume lot,
-Batch No,Lot nr.,
-Batch number is mandatory for Item {0},Numărul aferent lotului este obligatoriu pentru articolul {0},
-Batch {0} of Item {1} has expired.,Lot {0} din {1} Postul a expirat.,
-Batch {0} of Item {1} is disabled.,Lotul {0} al elementului {1} este dezactivat.,
-Batch: ,Lot:,
-Batches,Sarjele,
-Become a Seller,Deveniți un vânzător,
-Beginner,Începător,
-Bill,Factură,
-Bill Date,Dată factură,
-Bill No,Factură nr.,
-Bill of Materials,Reţete de Producţie,
-Bill of Materials (BOM),Lista de materiale (BOM),
-Billable Hours,Ore Billable,
-Billed,Facturat,
-Billed Amount,Sumă facturată,
-Billing,Facturare,
-Billing Address,Adresa De Facturare,
-Billing Address is same as Shipping Address,Adresa de facturare este aceeași cu adresa de expediere,
-Billing Amount,Suma de facturare,
-Billing Status,Stare facturare,
-Billing currency must be equal to either default company's currency or party account currency,"Valuta de facturare trebuie să fie identica fie cu valuta implicită a companiei, fie cu moneda contului de partid",
-Bills raised by Suppliers.,Facturi cu valoarea ridicată de către furnizori.,
-Bills raised to Customers.,Facturi cu valoarea ridicată pentru clienți.,
-Biotechnology,Biotehnologie,
-Birthday Reminder,Amintirea zilei de naștere,
-Black,Negru,
-Blanket Orders from Costumers.,Comenzi cuverturi de la clienți.,
-Block Invoice,Blocați factura,
-Boms,BOM,
-Bonus Payment Date cannot be a past date,Data de plată Bonus nu poate fi o dată trecută,
-Both Trial Period Start Date and Trial Period End Date must be set,"Trebuie să fie setată atât data de începere a perioadei de încercare, cât și data de încheiere a perioadei de încercare",
-Both Warehouse must belong to same Company,Ambele Depozite trebuie să aparțină aceleiași companii,
-Branch,ramură,
-Broadcasting,Transminiune,
-Brokerage,brokeraj,
-Browse BOM,Navigare BOM,
-Budget Against,Buget împotriva,
-Budget List,Lista de bugete,
-Budget Variance Report,Raport de variaţie buget,
-Budget cannot be assigned against Group Account {0},Buget nu pot fi atribuite în Grupa Contul {0},
-"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Bugetul nu pot fi atribuite în {0}, deoarece nu este un cont venituri sau cheltuieli",
-Buildings,Corpuri,
-Bundle items at time of sale.,Set de articole în momemntul vânzării.,
-Business Development Manager,Manager pentru Dezvoltarea Afacerilor,
-Buy,A cumpara,
-Buying,Cumpărare,
-Buying Amount,Sumă de cumpărare,
-Buying Price List,Achiziționarea listei de prețuri,
-Buying Rate,Rata de cumparare,
-"Buying must be checked, if Applicable For is selected as {0}","Destinat Cumpărării trebuie să fie bifat, dacă Se Aplica Pentru este selectat ca şi {0}",
-By {0},Până la {0},
-Bypass credit check at Sales Order ,Anulați verificarea creditului la Ordin de vânzări,
-C-Form records,Înregistrări formular-C,
-C-form is not applicable for Invoice: {0},Formularul C nu se aplică pentru factură: {0},
-CEO,CEO,
-CESS Amount,Suma CESS,
-CGST Amount,Suma CGST,
-CRM,CRM,
-CWIP Account,Contul CWIP,
-Calculated Bank Statement balance,Calculat Bank echilibru Declaratie,
-Calls,apeluri,
-Campaign,Campanie,
-Can be approved by {0},Poate fi aprobat/a de către {0},
-"Can not filter based on Account, if grouped by Account","Nu se poate filtra pe baza de cont, în cazul gruparii in functie de Cont",
-"Can not filter based on Voucher No, if grouped by Voucher","Nu se poate filtra pe baza voucher Nr., în cazul gruparii in functie de Voucher",
-"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Nu se poate marca evacuarea inpatientului, există facturi neachitate {0}",
-Can only make payment against unbilled {0},Plata se poate efectua numai în cazul factrilor neachitate {0},
-Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Se poate face referire la inregistrare numai dacă tipul de taxa este 'Suma inregistrare precedenta' sau 'Total inregistrare precedenta',
-"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Metoda de evaluare nu poate fi schimbată, deoarece există tranzacții împotriva anumitor elemente care nu au metoda de evaluare proprie",
-Can't create standard criteria. Please rename the criteria,Nu se pot crea criterii standard. Renunțați la criterii,
-Cancel,Anulează,
-Cancel Material Visit {0} before cancelling this Warranty Claim,Anulează Stivuitoare Vizitați {0} înainte de a anula acest revendicarea Garanție,
-Cancel Material Visits {0} before cancelling this Maintenance Visit,Anuleaza Vizite Material {0} înainte de a anula această Vizita de întreținere,
-Cancel Subscription,Anulează Abonament,
-Cancel the journal entry {0} first,Anulați mai întâi înregistrarea jurnalului {0},
-Canceled,Anulat,
-"Cannot Submit, Employees left to mark attendance","Nu se poate trimite, Angajații lăsați să marcheze prezența",
-Cannot be a fixed asset item as Stock Ledger is created.,"Nu poate fi un element de activ fix, deoarece este creat un registru de stoc.",
-Cannot cancel because submitted Stock Entry {0} exists,"Nu pot anula, deoarece a prezentat Bursa de intrare {0} există",
-Cannot cancel transaction for Completed Work Order.,Nu se poate anula tranzacția pentru comanda finalizată de lucru.,
-Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},Nu se poate anula {0} {1} deoarece numărul de serie {2} nu aparține depozitului {3},
-Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Nu se poate modifica atributele după tranzacția de stoc. Creați un element nou și transferați stocul la noul element,
-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 Service Stop Date for item in row {0},Nu se poate schimba data de începere a serviciului pentru elementul din rândul {0},
-Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Nu se pot modifica proprietățile Variant după tranzacția stoc. Va trebui să faceți un nou element pentru a face acest lucru.,
-"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Nu se poate schimba moneda implicita a companiei, deoarece există tranzacții in desfasurare. Tranzacțiile trebuie să fie anulate pentru a schimba moneda implicita.",
-Cannot change status as student {0} is linked with student application {1},Nu se poate schimba statutul de student ca {0} este legat cu aplicația de student {1},
-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 Account Type is selected.,Nu se poate sub acoperire la Grupul pentru că este selectată Tip cont.,
-Cannot create Retention Bonus for left Employees,Nu se poate crea Bonus de retenție pentru angajații stânga,
-Cannot create a Delivery Trip from Draft documents.,Nu se poate crea o călătorie de livrare din documentele Draft.,
-Cannot deactivate or cancel BOM as it is linked with other BOMs,"Nu se poate deactiva sau anula FDM, deoarece este conectat cu alte FDM-uri",
-"Cannot declare as lost, because Quotation has been made.","Nu se poate declara pierdut, pentru că Oferta a fost realizata.",
-Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Nu se poate deduce când categoria este de 'Evaluare' sau 'Evaluare și total',
-Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Nu se poate deduce atunci când este categoria de &quot;evaluare&quot; sau &quot;Vaulation și Total&quot;,
-"Cannot delete Serial No {0}, as it is used in stock transactions","Nu se poate șterge de serie nr {0}, așa cum este utilizat în tranzacțiile bursiere",
-Cannot enroll more than {0} students for this student group.,Nu se poate inscrie mai mult de {0} studenți pentru acest grup de studenți.,
-Cannot find active Leave Period,Nu se poate găsi perioada activă de plecare,
-Cannot produce more Item {0} than Sales Order quantity {1},Nu se pot produce mai multe Articole {0} decât cantitatea din Ordinul de Vânzări {1},
-Cannot promote Employee with status Left,Nu puteți promova angajatul cu starea Stânga,
-Cannot refer row number greater than or equal to current row number for this Charge type,Nu se poate face referire la un număr de inregistare mai mare sau egal cu numărul curent de inregistrare pentru acest tip de Incasare,
-Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Nu se poate selecta tipul de incasare ca 'Suma inregistrare precedenta' sau 'Total inregistrare precedenta' pentru prima inregistrare,
-Cannot set as Lost as Sales Order is made.,Nu se poate seta pierdut deoarece se intocmeste comandă de vânzări.,
-Cannot set authorization on basis of Discount for {0},Nu se poate seta autorizare pe baza de Discount pentru {0},
-Cannot set multiple Item Defaults for a company.,Nu se pot seta mai multe setări implicite pentru o companie.,
-Cannot set quantity less than delivered quantity,Cantitatea nu poate fi mai mică decât cea livrată,
-Cannot set quantity less than received quantity,Cantitatea nu poate fi mai mică decât cea primită,
-Cannot set the field <b>{0}</b> for copying in variants,Nu se poate seta câmpul <b>{0}</b> pentru copiere în variante,
-Cannot transfer Employee with status Left,Nu se poate transfera angajatul cu starea Stânga,
-Cannot {0} {1} {2} without any negative outstanding invoice,Nu se poate {0} {1} {2} in lipsa unei facturi negative restante,
-Capital Equipments,Echipamente de capital,
-Capital Stock,Capital Stock,
-Capital Work in Progress,Capitalul în curs de desfășurare,
-Cart,Coș,
-Cart is Empty,Cosul este gol,
-Case No(s) already in use. Try from Case No {0},Cazul nr. (s) este deja utilizat. Încercați din cazul nr. {s},
-Cash,Numerar,
-Cash Flow Statement,Situația fluxurilor de trezorerie,
-Cash Flow from Financing,Cash Flow de la finanțarea,
-Cash Flow from Investing,Cash Flow de la Investiții,
-Cash Flow from Operations,Cash Flow din Operațiuni,
-Cash In Hand,Bani în mână,
-Cash or Bank Account is mandatory for making payment entry,Pentru a face o inregistrare de plată este obligatoriu numerar sau cont bancar,
-Cashier Closing,Încheierea caselor,
-Casual Leave,Concediu Aleator,
-Category,Categorie,
-Category Name,Nume Categorie,
-Caution,Prudență,
-Central Tax,Impozitul central,
-Certification,Certificare,
-Cess,CESS,
-Change Amount,Sumă schimbare,
-Change Item Code,Modificați codul elementului,
-Change Release Date,Modificați data de lansare,
-Change Template Code,Schimbați codul de șablon,
-Changing Customer Group for the selected Customer is not allowed.,Schimbarea Grupului de Clienți pentru Clientul selectat nu este permisă.,
-Chapter,Capitol,
-Chapter information.,Informații despre capitol.,
-Charge of type 'Actual' in row {0} cannot be included in Item Rate,"Taxa de tip 'Efectiv' în inregistrarea {0} nu poate fi inclus în Rata Articol""",
-Chargeble,Chargeble,
-Charges are updated in Purchase Receipt against each item,Tarifele sunt actualizate în Primirea cumparare pentru fiecare articol,
-"Charges will be distributed proportionately based on item qty or amount, as per your selection","Taxele vor fi distribuite proporțional în funcție de produs Cantitate sau valoarea, ca pe dvs. de selecție",
-Chart of Cost Centers,Diagramă Centre de Cost,
-Check all,Selectați toate,
-Checkout,Verifică,
-Chemical,Chimic,
-Cheque,Cec,
-Cheque/Reference No,Cecul / de referință nr,
-Cheques Required,Verificări necesare,
-Cheques and Deposits incorrectly cleared,Cecuri și Depozite respingă incorect,
-Child Task exists for this Task. You can not delete this Task.,Sarcina pentru copii există pentru această sarcină. Nu puteți șterge această activitate.,
-Child nodes can be only created under 'Group' type nodes,noduri pentru copii pot fi create numai în noduri de tip &quot;grup&quot;,
-Child warehouse exists for this warehouse. You can not delete this warehouse.,Există depozit copil pentru acest depozit. Nu puteți șterge acest depozit.,
-Circular Reference Error,Eroare de referință Circular,
-City,Oraș,
-City/Town,Oras/Localitate,
-Claimed Amount,Suma solicitată,
-Clay,Lut,
-Clear filters,Șterge filtrele,
-Clear values,Valori clare,
-Clearance Date,Data Aprobare,
-Clearance Date not mentioned,Data Aprobare nespecificata,
-Clearance Date updated,Clearance-ul Data actualizat,
-Client,Client,
-Client ID,ID-ul clientului,
-Client Secret,Secret Client,
-Clinical Procedure,Procedura clinică,
-Clinical Procedure Template,Formularul procedurii clinice,
-Close Balance Sheet and book Profit or Loss.,Inchideti Bilanțul și registrul Profit sau Pierdere.,
-Close Loan,Împrumut închis,
-Close the POS,Închideți POS,
-Closed,Închis,
-Closed order cannot be cancelled. Unclose to cancel.,Pentru închis nu poate fi anulată. Pentru a anula redeschide.,
-Closing (Cr),De închidere (Cr),
-Closing (Dr),De închidere (Dr),
-Closing (Opening + Total),Închidere (Deschidere + Total),
-Closing Account {0} must be of type Liability / Equity,Contul {0} de închidere trebuie să fie de tip răspunderii / capitaluri proprii,
-Closing Balance,Soldul de încheiere,
-Code,Cod,
-Collapse All,Reduceți totul În această,
-Color,Culoare,
-Colour,Culoare,
-Combined invoice portion must equal 100%,Partea facturată combinată trebuie să fie egală cu 100%,
-Commercial,Comercial,
-Commission,Comision,
-Commission Rate %,Rata comisionului %,
-Commission on Sales,Comision pentru Vânzări,
-Commission rate cannot be greater than 100,Rata de comision nu poate fi mai mare decat 100,
-Community Forum,Community Forum,
-Company (not Customer or Supplier) master.,Directorul Companiei(nu al Clientului sau al Furnizorui).,
-Company Abbreviation,Abreviere Companie,
-Company Abbreviation cannot have more than 5 characters,Abrevierea companiei nu poate avea mai mult de 5 caractere,
-Company Name,Denumire Furnizor,
-Company Name cannot be Company,Numele Companiei nu poate fi Companie,
-Company currencies of both the companies should match for Inter Company Transactions.,Monedele companiilor ambelor companii ar trebui să se potrivească cu tranzacțiile Inter-Company.,
-Company is manadatory for company account,Compania este managerială pentru contul companiei,
-Company name not same,Numele companiei nu este același,
-Company {0} does not exist,Firma {0} nu există,
-Compensatory Off,Fara Masuri Compensatorii,
-Compensatory leave request days not in valid holidays,Plățile compensatorii pleacă în zilele de sărbători valabile,
-Complaint,Reclamație,
-Completion Date,Data Finalizare,
-Computer,Computer,
-Condition,Condiție,
-Configure,Configurarea,
-Configure {0},Configurare {0},
-Confirmed orders from Customers.,Comenzi confirmate de la clienți.,
-Connect Amazon with ERPNext,Conectați-vă la Amazon cu ERPNext,
-Connect Shopify with ERPNext,Conectați-vă la Shopify cu ERPNext,
-Connect to Quickbooks,Conectați-vă la agendele rapide,
-Connected to QuickBooks,Conectat la QuickBooks,
-Connecting to QuickBooks,Conectarea la QuickBooks,
-Consultation,Consultare,
-Consultations,consultări,
-Consulting,Consilia,
-Consumable,Consumabile,
-Consumed,Consumat,
-Consumed Amount,Consumat Suma,
-Consumed Qty,Cantitate consumată,
-Consumer Products,Produse consumator,
-Contact,Persoana de Contact,
-Contact Details,Detalii Persoana de Contact,
-Contact Number,Numar de contact,
-Contact Us,Contacteaza-ne,
-Content,Continut,
-Content Masters,Maeștri de conținut,
-Content Type,Tip Conținut,
-Continue Configuration,Continuați configurarea,
-Contract,Contract,
-Contract End Date must be greater than Date of Joining,Data de Incheiere Contract trebuie să fie ulterioara Datei Aderării,
-Contribution %,Contribuția%,
-Contribution Amount,Contribuția Suma,
-Conversion factor for default Unit of Measure must be 1 in row {0},Factor de Conversie pentru Unitatea de Măsură implicita trebuie să fie 1 pentru inregistrarea {0},
-Conversion rate cannot be 0 or 1,Rata de conversie nu poate fi 0 sau 1,
-Convert to Group,Transformă în grup,
-Convert to Non-Group,Converti la non-Group,
-Cosmetics,Cosmetică,
-Cost Center,Centrul de cost,
-Cost Center Number,Numărul centrului de costuri,
-Cost Center and Budgeting,Centrul de costuri și buget,
-Cost Center is required in row {0} in Taxes table for type {1},Centrul de Cost este necesar pentru inregistrarea {0} din tabelul Taxe pentru tipul {1},
-Cost Center with existing transactions can not be converted to group,Centrul de Cost cu tranzacții existente nu poate fi transformat în grup,
-Cost Center with existing transactions can not be converted to ledger,Centrul de Cost cu tranzacții existente nu poate fi transformat în registru contabil,
-Cost Centers,Centre de cost,
-Cost Updated,Cost actualizat,
-Cost as on,Cost cu o schimbare ca pe,
-Cost of Delivered Items,Costul de articole livrate,
-Cost of Goods Sold,Cost Bunuri Vândute,
-Cost of Issued Items,Costul de articole emise,
-Cost of New Purchase,Costul de achiziție nouă,
-Cost of Purchased Items,Costul de produsele cumparate,
-Cost of Scrapped Asset,Costul de active scoase din uz,
-Cost of Sold Asset,Costul de active vândute,
-Cost of various activities,Costul diverse activități,
-"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Nu s-a putut crea Nota de credit în mod automat, debifați &quot;Notați nota de credit&quot; și trimiteți-o din nou",
-Could not generate Secret,Nu am putut genera secret,
-Could not retrieve information for {0}.,Nu s-au putut obține informații pentru {0}.,
-Could not solve criteria score function for {0}. Make sure the formula is valid.,Nu s-a putut rezolva funcția de evaluare a criteriilor pentru {0}. Asigurați-vă că formula este validă.,
-Could not solve weighted score function. Make sure the formula is valid.,Nu s-a putut rezolva funcția de scor ponderat. Asigurați-vă că formula este validă.,
-Could not submit some Salary Slips,Nu am putut trimite unele Salariile,
-"Could not update stock, invoice contains drop shipping item.","Nu s-a putut actualiza stocul, factura conține elementul de expediere.",
-Country wise default Address Templates,Șabloanele țară înțelept adresa implicită,
-Course,Curs,
-Course Code: ,Codul cursului:,
-Course Enrollment {0} does not exists,Înscrierea la curs {0} nu există,
-Course Schedule,Program de curs de,
-Course: ,Curs:,
-Cr,Cr,
-Create,Creează,
-Create BOM,Creați BOM,
-Create Delivery Trip,Creați călătorie de livrare,
-Create Disbursement Entry,Creați intrare pentru dezbursare,
-Create Employee,Creați angajat,
-Create Employee Records,Crearea angajaților Records,
-"Create Employee records to manage leaves, expense claims and payroll","Crearea de înregistrări angajaților pentru a gestiona frunze, cheltuieli și salarizare creanțe",
-Create Fee Schedule,Creați programul de taxe,
-Create Fees,Creați taxe,
-Create Inter Company Journal Entry,Creați jurnalul companiei Inter,
-Create Invoice,Creați factură,
-Create Invoices,Creați facturi,
-Create Job Card,Creați carte de muncă,
-Create Journal Entry,Creați intrarea în jurnal,
-Create Lead,Creați Lead,
-Create Leads,Creează Piste,
-Create Maintenance Visit,Creați vizită de întreținere,
-Create Material Request,Creați solicitare de materiale,
-Create Multiple,Creați mai multe,
-Create Opening Sales and Purchase Invoices,Creați deschiderea vânzărilor și facturilor de achiziție,
-Create Payment Entries,Creați intrări de plată,
-Create Payment Entry,Creați intrare de plată,
-Create Print Format,Creați Format imprimare,
-Create Purchase Order,Creați comanda de aprovizionare,
-Create Purchase Orders,Creare comenzi de aprovizionare,
-Create Quotation,Creare Ofertă,
-Create Salary Slip,Crea Fluturasul de Salariul,
-Create Salary Slips,Creați buletine de salariu,
-Create Sales Invoice,Creați factură de vânzări,
-Create Sales Order,Creați o comandă de vânzări,
-Create Sales Orders to help you plan your work and deliver on-time,Creați comenzi de vânzare pentru a vă ajuta să vă planificați munca și să vă livrați la timp,
-Create Sample Retention Stock Entry,Creați intrare de stoc de reținere a eșantionului,
-Create Student,Creați student,
-Create Student Batch,Creați lot de elevi,
-Create Student Groups,Creați Grupurile de studenți,
-Create Supplier Quotation,Creați ofertă pentru furnizori,
-Create Tax Template,Creați șablonul fiscal,
-Create Timesheet,Creați o foaie de lucru,
-Create User,Creaza utilizator,
-Create Users,Creați utilizatori,
-Create Variant,Creați varianta,
-Create Variants,Creați variante,
-"Create and manage daily, weekly and monthly email digests.","Creare și gestionare rezumate e-mail zilnice, săptămânale și lunare.",
-Create customer quotes,Creați citate client,
-Create rules to restrict transactions based on values.,Creare reguli pentru restricționare tranzacții bazate pe valori.,
-Created {0} scorecards for {1} between: ,A creat {0} cărți de scor pentru {1} între:,
-Creating Company and Importing Chart of Accounts,Crearea companiei și importul graficului de conturi,
-Creating Fees,Crearea de taxe,
-Creating Payment Entries......,Crearea intrărilor de plată ......,
-Creating Salary Slips...,Crearea salvărilor salariale ...,
-Creating student groups,Crearea grupurilor de studenți,
-Creating {0} Invoice,Crearea facturii {0},
-Credit,Credit,
-Credit ({0}),Credit ({0}),
-Credit Account,Cont de credit,
-Credit Balance,Balanța de credit,
-Credit Card,Card de credit,
-Credit Days cannot be a negative number,Zilele de credit nu pot fi un număr negativ,
-Credit Limit,Limita de credit,
-Credit Note,Nota de credit,
-Credit Note Amount,Nota de credit Notă,
-Credit Note Issued,Nota de credit Eliberat,
-Credit Note {0} has been created automatically,Nota de credit {0} a fost creată automat,
-Credit limit has been crossed for customer {0} ({1}/{2}),Limita de credit a fost depășită pentru clientul {0} ({1} / {2}),
-Creditors,creditorii,
-Criteria weights must add up to 100%,Criteriile de greutate trebuie să adauge până la 100%,
-Crop Cycle,Ciclu de recoltare,
-Crops & Lands,Culturi și terenuri,
-Currency Exchange must be applicable for Buying or for Selling.,Cursul valutar trebuie să fie aplicabil pentru cumpărare sau pentru vânzare.,
-Currency can not be changed after making entries using some other currency,Moneda nu poate fi schimbat după efectuarea înregistrări folosind un altă valută,
-Currency exchange rate master.,Maestru cursului de schimb valutar.,
-Currency for {0} must be {1},Moneda pentru {0} trebuie să fie {1},
-Currency is required for Price List {0},Moneda este necesară pentru lista de prețuri {0},
-Currency of the Closing Account must be {0},Valuta contului de închidere trebuie să fie {0},
-Currency of the price list {0} must be {1} or {2},Moneda din lista de prețuri {0} trebuie să fie {1} sau {2},
-Currency should be same as Price List Currency: {0},Valuta trebuie sa fie aceeasi cu Moneda Preturilor: {0},
-Current,Actual,
-Current Assets,Active curente,
-Current BOM and New BOM can not be same,FDM-ul curent și FDM-ul nou nu pot fi identici,
-Current Job Openings,Locuri de munca disponibile,
-Current Liabilities,Raspunderi Curente,
-Current Qty,Cantitate curentă,
-Current invoice {0} is missing,Factura curentă {0} lipsește,
-Custom HTML,Personalizat HTML,
-Custom?,Personalizat?,
-Customer,Client,
-Customer Addresses And Contacts,Adrese de clienți și Contacte,
-Customer Contact,Clientul A lua legatura,
-Customer Database.,Baza de Date Client.,
-Customer Group,Grup Clienți,
-Customer LPO,Clientul LPO,
-Customer LPO No.,Client nr. LPO,
-Customer Name,Nume client,
-Customer POS Id,ID POS utilizator,
-Customer Service,Service Client,
-Customer and Supplier,Client și Furnizor,
-Customer is required,Clientul este necesar,
-Customer isn't enrolled in any Loyalty Program,Clientul nu este înscris în niciun program de loialitate,
-Customer required for 'Customerwise Discount',Client necesar pentru 'Reducere Client',
-Customer {0} does not belong to project {1},Clientul {0} nu aparține proiectului {1},
-Customer {0} is created.,Clientul {0} este creat.,
-Customers in Queue,Clienții din coadă,
-Customize Homepage Sections,Personalizați secțiunile homepage,
-Customizing Forms,Personalizare Formulare,
-Daily Project Summary for {0},Rezumatul zilnic al proiectului pentru {0},
-Daily Reminders,Memento de zi cu zi,
-Daily Work Summary,Sumar Zilnic de Lucru,
-Daily Work Summary Group,Grup de lucru zilnic de lucru,
-Data Import and Export,Datele de import și export,
-Data Import and Settings,Import de date și setări,
-Database of potential customers.,Bază de date cu clienți potențiali.,
-Date Format,Format Dată,
-Date Of Retirement must be greater than Date of Joining,Data Pensionare trebuie să fie ulterioara Datei Aderării,
-Date is repeated,Data se repetă,
-Date of Birth,Data Nașterii,
-Date of Birth cannot be greater than today.,Data Nașterii nu poate fi mai mare decât în prezent.,
-Date of Commencement should be greater than Date of Incorporation,Data de Începere ar trebui să fie mai mare decât data înființării,
-Date of Joining,Data aderării,
-Date of Joining must be greater than Date of Birth,Data Aderării trebuie să fie ulterioara Datei Nașterii,
-Date of Transaction,Data tranzacției,
-Datetime,DatăTimp,
-Day,Zi,
-Debit,Debit,
-Debit ({0}),Debit ({0}),
-Debit A/C Number,Număr de debit A / C,
-Debit Account,Cont Debit,
-Debit Note,Notă Debit,
-Debit Note Amount,Sumă Notă Debit,
-Debit Note Issued,Notă Debit Eliberată,
-Debit To is required,Pentru debit este necesar,
-Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debit și credit nu este egal pentru {0} # {1}. Diferența este {2}.,
-Debtors,Debitori,
-Debtors ({0}),Debitorilor ({0}),
-Declare Lost,Declar pierdut,
-Deduction,Deducere,
-Default Activity Cost exists for Activity Type - {0},Există implicit Activitate Cost de activitate de tip - {0},
-Default BOM ({0}) must be active for this item or its template,Implicit BOM ({0}) trebuie să fie activ pentru acest element sau șablon de,
-Default BOM for {0} not found,BOM implicit pentru {0} nu a fost găsit,
-Default BOM not found for Item {0} and Project {1},Implicit BOM nu a fost găsit pentru articolele {0} și proiectul {1},
-Default Letter Head,Implicit Scrisoare Șef,
-Default Tax Template,Implicit Template fiscal,
-Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Unitatea de măsură implicită pentru postul {0} nu poate fi schimbat direct, deoarece aveti si voi deja unele tranzacții (i) cu un alt UOM. Veți avea nevoie pentru a crea un nou element pentru a utiliza un alt implicit UOM.",
-Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Unitatea implicit de măsură pentru Variant &#39;{0} &quot;trebuie să fie la fel ca în Template&quot; {1} &quot;,
-Default settings for buying transactions.,Setări implicite pentru tranzacțiilor de achizitie.,
-Default settings for selling transactions.,Setări implicite pentru tranzacțiile de vânzare.,
-Default tax templates for sales and purchase are created.,Se creează șabloane fiscale predefinite pentru vânzări și achiziții.,
-Defaults,Implicite,
-Defense,Apărare,
-Define Project type.,Definiți tipul de proiect.,
-Define budget for a financial year.,Definiți bugetul pentru un exercițiu financiar.,
-Define various loan types,Definirea diferitelor tipuri de împrumut,
-Del,del,
-Delay in payment (Days),Întârziere de plată (zile),
-Delete all the Transactions for this Company,Ștergeți toate tranzacțiile de acest companie,
-Deletion is not permitted for country {0},Ștergerea nu este permisă pentru țara {0},
-Delivered,Livrat,
-Delivered Amount,Suma Pronunțată,
-Delivered Qty,Cantitate Livrata,
-Delivered: {0},Livrate: {0},
-Delivery,Livrare,
-Delivery Date,Data de Livrare,
-Delivery Note,Nota de Livrare,
-Delivery Note {0} is not submitted,Nota de Livrare {0} nu este introdusa,
-Delivery Note {0} must not be submitted,Nota de Livrare {0} nu trebuie sa fie introdusa,
-Delivery Notes {0} must be cancelled before cancelling this Sales Order,Nota de Livrare {0} trebuie sa fie anulată înainte de a anula aceasta Comandă de Vânzări,
-Delivery Notes {0} updated,Notele de livrare {0} sunt actualizate,
-Delivery Status,Starea de Livrare,
-Delivery Trip,Excursie la expediere,
-Delivery warehouse required for stock item {0},Depozit de livrare necesar pentru articol stoc {0},
-Department,Departament,
-Department Stores,Magazine Departament,
-Depreciation,Depreciere,
-Depreciation Amount,Sumă de amortizare,
-Depreciation Amount during the period,Suma de amortizare în timpul perioadei,
-Depreciation Date,Data de amortizare,
-Depreciation Eliminated due to disposal of assets,Amortizare Eliminată din cauza eliminării activelor,
-Depreciation Entry,amortizare intrare,
-Depreciation Method,Metoda de amortizare,
-Depreciation Row {0}: Depreciation Start Date is entered as past date,Rândul de amortizare {0}: Data de începere a amortizării este introdusă ca dată trecută,
-Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Rata de amortizare {0}: Valoarea estimată după viața utilă trebuie să fie mai mare sau egală cu {1},
-Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Rândul de amortizare {0}: Data următoarei amortizări nu poate fi înaintea datei disponibile pentru utilizare,
-Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Rata de amortizare {0}: Data următoare a amortizării nu poate fi înainte de data achiziției,
-Designer,proiectant,
-Detailed Reason,Motiv detaliat,
-Details,Detalii,
-Details of Outward Supplies and inward supplies liable to reverse charge,"Detalii despre consumabile externe și consumabile interioare, care pot fi percepute invers",
-Details of the operations carried out.,Detalii privind operațiunile efectuate.,
-Diagnosis,Diagnostic,
-Did not find any item called {0},Nu am gasit nici un element numit {0},
-Diff Qty,Cantitate diferențială,
-Difference Account,Diferența de Cont,
-"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Diferența cont trebuie să fie un cont de tip activ / pasiv, deoarece acest stoc Reconcilierea este un intrare de deschidere",
-Difference Amount,Diferență Sumă,
-Difference Amount must be zero,Diferența Suma trebuie să fie zero,
-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.,Un UOM diferit pentru articole va conduce la o valoare incorecta pentru Greutate Neta (Total). Asigurați-vă că Greutatea Netă a fiecărui articol este în același UOM.,
-Direct Expenses,Cheltuieli directe,
-Direct Income,Venituri Directe,
-Disable,Dezactivați,
-Disabled template must not be default template,șablon cu handicap nu trebuie să fie șablon implicit,
-Disburse Loan,Împrumut de debit,
-Disbursed,debursate,
-Disc,Disc,
-Discharge,descărcare,
-Discount,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,Reducerea trebuie să fie mai mică de 100,
-Diseases & Fertilizers,Boli și îngrășăminte,
-Dispatch,Expediere,
-Dispatch Notification,Notificare de expediere,
-Dispatch State,Statul de expediere,
-Distance,Distanţă,
-Distribution,distribuire,
-Distributor,Distribuitor,
-Dividends Paid,Dividendele plătite,
-Do you really want to restore this scrapped asset?,Sigur doriți să restabiliți acest activ casate?,
-Do you really want to scrap this asset?,Chiar vrei să resturi acest activ?,
-Do you want to notify all the customers by email?,Doriți să notificăți toți clienții prin e-mail?,
-Doc Date,Data Documentelor,
-Doc Name,Denumire Doc,
-Doc Type,Tip Doc,
-Docs Search,Căutare în Docs,
-Document Name,Document Nume,
-Document Status,Stare Document,
-Document Type,Tip Document,
-Domain,Domeniu,
-Domains,Domenii,
-Done,Făcut,
-Donor,Donator,
-Donor Type information.,Informații tip donator.,
-Donor information.,Informații despre donator.,
-Download JSON,Descărcați JSON,
-Draft,Proiect,
-Drop Ship,Drop navelor,
-Drug,Medicament,
-Due / Reference Date cannot be after {0},Datorită / Reference Data nu poate fi după {0},
-Due Date cannot be before Posting / Supplier Invoice Date,Data scadentă nu poate fi înainte de data de înregistrare / factură a furnizorului,
-Due Date is mandatory,Due Date este obligatorie,
-Duplicate Entry. Please check Authorization Rule {0},Inregistrare Duplicat. Vă rugăm să verificați Regula de Autorizare {0},
-Duplicate Serial No entered for Item {0},Nr. Serial introdus pentru articolul {0} este duplicat,
-Duplicate customer group found in the cutomer group table,grup de clienți dublu exemplar găsit în tabelul grupului cutomer,
-Duplicate entry,Inregistrare duplicat,
-Duplicate item group found in the item group table,Grup de element dublu exemplar găsit în tabelul de grup de elemente,
-Duplicate roll number for student {0},Numărul de rolă duplicat pentru student {0},
-Duplicate row {0} with same {1},Inregistrare {0} este duplicata cu aceeași {1},
-Duplicate {0} found in the table,Duplicat {0} găsit în tabel,
-Duration in Days,Durata în Zile,
-Duties and Taxes,Impozite și taxe,
-E-Invoicing Information Missing,Informații privind facturarea electronică lipsă,
-ERPNext Demo,ERPNext Demo,
-ERPNext Settings,Setări ERPNext,
-Earliest,cel mai devreme,
-Earnest Money,Banii cei mai castigati,
-Earning,Câștig Salarial,
-Edit,Editați | ×,
-Edit Publishing Details,Editați detaliile publicării,
-"Edit in full page for more options like assets, serial nos, batches etc.","Modificați pe pagina completă pentru mai multe opțiuni, cum ar fi active, numere de serie, loturi etc.",
-Education,Educaţie,
-Either location or employee must be required,Trebuie să fie necesară locația sau angajatul,
-Either target qty or target amount is mandatory,Cantitatea țintă sau valoarea țintă este obligatorie,
-Either target qty or target amount is mandatory.,Cantitatea țintă sau valoarea țintă este obligatorie.,
-Electrical,Electric,
-Electronic Equipments,Echipamente electronice,
-Electronics,Electronică,
-Eligible ITC,ITC eligibil,
-Email Account,Contul de e-mail,
-Email Address,Adresa de email,
-"Email Address must be unique, already exists for {0}","Adresa de e-mail trebuie să fie unic, există deja pentru {0}",
-Email Digest: ,Email Digest:,
-Email Reminders will be sent to all parties with email contacts,Mementourile de e-mail vor fi trimise tuturor părților cu contacte de e-mail,
-Email Sent,E-mail trimis,
-Email Template,Șablon de e-mail,
-Email not found in default contact,E-mailul nu a fost găsit în contactul implicit,
-Email sent to {0},E-mail trimis la {0},
-Employee,Angajat,
-Employee A/C Number,Numărul A / C al angajaților,
-Employee Advances,Avansuri ale angajaților,
-Employee Benefits,Beneficiile angajatului,
-Employee Grade,Clasa angajatilor,
-Employee ID,card de identitate al angajatului,
-Employee Lifecycle,Durata de viață a angajatului,
-Employee Name,Nume angajat,
-Employee Promotion cannot be submitted before Promotion Date ,Promovarea angajaților nu poate fi depusă înainte de data promoției,
-Employee Referral,Referirea angajaților,
-Employee Transfer cannot be submitted before Transfer Date ,Transferul angajaților nu poate fi depus înainte de data transferului,
-Employee cannot report to himself.,Angajat nu pot raporta la sine.,
-Employee relieved on {0} must be set as 'Left',Angajat eliberat din finctie pe {0} trebuie să fie setat ca 'Plecat',
-Employee {0} already submited an apllication {1} for the payroll period {2},Angajatul {0} a trimis deja o aplicație {1} pentru perioada de plată {2},
-Employee {0} has already applied for {1} between {2} and {3} : ,Angajatul {0} a solicitat deja {1} între {2} și {3}:,
-Employee {0} has no maximum benefit amount,Angajatul {0} nu are o valoare maximă a beneficiului,
-Employee {0} is not active or does not exist,Angajatul {0} nu este activ sau nu există,
-Employee {0} is on Leave on {1},Angajatul {0} este activat Lăsați pe {1},
-Employee {0} of grade {1} have no default leave policy,Angajații {0} ai clasei {1} nu au o politică de concediu implicită,
-Employee {0} on Half day on {1},Angajat {0} pe jumătate de zi pe {1},
-Enable,Activare,
-Enable / disable currencies.,Activare / dezactivare valute.,
-Enabled,Activat,
-"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Dacă activați opțiunea &quot;Utilizare pentru Cos de cumparaturi &#39;, ca Cosul de cumparaturi este activat și trebuie să existe cel puțin o regulă fiscală pentru Cos de cumparaturi",
-End Date,Dată finalizare,
-End Date can not be less than Start Date,Data de încheiere nu poate fi mai mică decât data de începere,
-End Date cannot be before Start Date.,Data de încheiere nu poate fi înainte de data de începere.,
-End Year,Anul de încheiere,
-End Year cannot be before Start Year,Sfârșitul anului nu poate fi înainte de Anul de început,
-End on,Terminați,
-End time cannot be before start time,Ora de încheiere nu poate fi înainte de ora de începere,
-Ends On date cannot be before Next Contact Date.,Sfârșitul de data nu poate fi înaintea datei următoarei persoane de contact.,
-Energy,Energie,
-Engineer,Inginer,
-Enough Parts to Build,Piese de schimb suficient pentru a construi,
-Enroll,A se inscrie,
-Enrolling student,student inregistrat,
-Enrolling students,Înscrierea studenților,
-Enter depreciation details,Introduceți detaliile de depreciere,
-Enter the Bank Guarantee Number before submittting.,Introduceți numărul de garanție bancară înainte de depunere.,
-Enter the name of the Beneficiary before submittting.,Introduceți numele Beneficiarului înainte de depunerea.,
-Enter the name of the bank or lending institution before submittting.,Introduceți numele băncii sau al instituției de credit înainte de depunere.,
-Enter value betweeen {0} and {1},Introduceți valoarea dintre {0} și {1},
-Entertainment & Leisure,Divertisment & Relaxare,
-Entertainment Expenses,Cheltuieli de Divertisment,
-Equity,echitate,
-Error Log,eroare Log,
-Error evaluating the criteria formula,Eroare la evaluarea formulei de criterii,
-Error in formula or condition: {0},Eroare în formulă sau o condiție: {0},
-Error: Not a valid id?,Eroare: Nu a id valid?,
-Estimated Cost,Cost estimat,
-Evaluation,Evaluare,
-"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:",
-Event,Eveniment,
-Event Location,Locația evenimentului,
-Event Name,Numele evenimentului,
-Exchange Gain/Loss,Cheltuiala / Venit din diferente de curs valutar,
-Exchange Rate Revaluation master.,Master reevaluarea cursului de schimb.,
-Exchange Rate must be same as {0} {1} ({2}),Cursul de schimb trebuie să fie același ca și {0} {1} ({2}),
-Excise Invoice,Factura acciza,
-Execution,Execuţie,
-Executive Search,Cautare executiva,
-Expand All,Extinde toate,
-Expected Delivery Date,Data de Livrare Preconizata,
-Expected Delivery Date should be after Sales Order Date,Data de livrare preconizată trebuie să fie după data de comandă de vânzare,
-Expected End Date,Data de Incheiere Preconizata,
-Expected Hrs,Se așteptau ore,
-Expected Start Date,Data de Incepere Preconizata,
-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,Cont de cheltuieli,
-Expense Claim,Solicitare Cheltuială,
-Expense Claim for Vehicle Log {0},Solicitare Cheltuială pentru Log Vehicul {0},
-Expense Claim {0} already exists for the Vehicle Log,Solicitare Cheltuială {0} există deja pentru Log Vehicul,
-Expense Claims,Creanțe cheltuieli,
-Expense account is mandatory for item {0},Cont de cheltuieli este obligatoriu pentru articolul {0},
-Expenses,cheltuieli,
-Expenses Included In Asset Valuation,Cheltuieli incluse în evaluarea activelor,
-Expenses Included In Valuation,Cheltuieli incluse în evaluare,
-Expired Batches,Loturile expirate,
-Expires On,Expira la,
-Expiring On,Expirând On,
-Expiry (In Days),Expirării (în zile),
-Explore,Explorați,
-Export E-Invoices,Export facturi electronice,
-Extra Large,Extra mare,
-Extra Small,Extra Small,
-Fail,eșua,
-Failed,A eșuat,
-Failed to create website,Eroare la crearea site-ului,
-Failed to install presets,Eroare la instalarea presetărilor,
-Failed to login,Eroare la autentificare,
-Failed to setup company,Setarea companiei nu a reușit,
-Failed to setup defaults,Setările prestabilite nu au reușit,
-Failed to setup post company fixtures,Nu sa reușit configurarea posturilor companiei,
-Fax,Fax,
-Fee,taxă,
-Fee Created,Taxa a fost creată,
-Fee Creation Failed,Crearea de comisioane a eșuat,
-Fee Creation Pending,Crearea taxelor în așteptare,
-Fee Records Created - {0},Taxa de inregistrare Creat - {0},
-Feedback,Reactie,
-Fees,Taxele de,
-Female,Feminin,
-Fetch Data,Fetch Data,
-Fetch Subscription Updates,Actualizați abonamentul la preluare,
-Fetch exploded BOM (including sub-assemblies),Obtine FDM expandat (inclusiv subansamblurile),
-Fetching records......,Recuperarea înregistrărilor ......,
-Field Name,Nume câmp,
-Fieldname,Nume câmp,
-Fields,Câmpuri,
-Fill the form and save it,Completați formularul și salvați-l,
-Filter Employees By (Optional),Filtrați angajații după (opțional),
-"Filter Fields Row #{0}: Fieldname <b>{1}</b> must be of type ""Link"" or ""Table MultiSelect""",Rândul câmpurilor de filtrare # {0}: Numele de câmp <b>{1}</b> trebuie să fie de tipul &quot;Link&quot; sau &quot;MultiSelect de tabel&quot;,
-Filter Total Zero Qty,Filtrați numărul total zero,
-Finance Book,Cartea de finanțe,
-Financial / accounting year.,An financiar / contabil.,
-Financial Services,Servicii financiare,
-Financial Statements,Situațiile financiare,
-Financial Year,An financiar,
-Finish,finalizarea,
-Finished Good,Terminat bine,
-Finished Good Item Code,Cod articol bun finalizat,
-Finished Goods,Produse finite,
-Finished Item {0} must be entered for Manufacture type entry,Postul terminat {0} trebuie să fie introdusă de intrare de tip fabricarea,
-Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Produsul finit <b>{0}</b> și Cantitatea <b>{1}</b> nu pot fi diferite,
-First Name,Prenume,
-"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","Regimul fiscal este obligatoriu, vă rugăm să setați regimul fiscal în companie {0}",
-Fiscal Year,An fiscal,
-Fiscal Year End Date should be one year after Fiscal Year Start Date,Data de încheiere a anului fiscal trebuie să fie un an de la data începerii anului fiscal,
-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 should be one year earlier than Fiscal Year End Date,Data de începere a anului fiscal ar trebui să fie cu un an mai devreme decât data de încheiere a anului fiscal,
-Fiscal Year {0} does not exist,Anul fiscal {0} nu există,
-Fiscal Year {0} is required,Anul fiscal {0} este necesară,
-Fiscal Year {0} not found,Anul fiscal {0} nu a fost găsit,
-Fixed Asset,Activ Fix,
-Fixed Asset Item must be a non-stock item.,Fix elementul de activ trebuie să fie un element de bază non-stoc.,
-Fixed Assets,Active Fixe,
-Following Material Requests have been raised automatically based on Item's re-order level,Ca urmare a solicitărilor de materiale au fost ridicate în mod automat în funcție de nivelul de re-comanda item,
-Following accounts might be selected in GST Settings:,Următoarele conturi ar putea fi selectate în Setări GST:,
-Following course schedules were created,Următoarele programe au fost create,
-Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Următorul articol {0} nu este marcat ca {1} element. Puteți să le activați ca element {1} din capitolul Articol,
-Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,Următoarele elemente {0} nu sunt marcate ca {1} element. Puteți să le activați ca element {1} din capitolul Articol,
-Food,Produse Alimentare,
-"Food, Beverage & Tobacco","Produse Alimentare, Bauturi si Tutun",
-For,Pentru,
-"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Pentru elementele &quot;produse Bundle&quot;, Warehouse, Serial No și lot nr vor fi luate în considerare de la &quot;ambalare List&quot; masa. Dacă Warehouse și Lot nr sunt aceleași pentru toate elementele de ambalaj pentru produs orice &quot;Bundle produs&quot;, aceste valori pot fi introduse în tabelul de punctul principal, valorile vor fi copiate &quot;de ambalare Lista&quot; masă.",
-For Employee,Pentru angajat,
-For Quantity (Manufactured Qty) is mandatory,Pentru Cantitate (fabricat Cant) este obligatorie,
-For Supplier,Pentru Furnizor,
-For Warehouse,Pentru depozit,
-For Warehouse is required before Submit,Pentru Depozit este necesar înainte de Inregistrare,
-"For an item {0}, quantity must be negative number","Pentru un element {0}, cantitatea trebuie să fie număr negativ",
-"For an item {0}, quantity must be positive number","Pentru un element {0}, cantitatea trebuie să fie un număr pozitiv",
-"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","Pentru cartea de muncă {0}, puteți înscrie doar stocul de tip „Transfer de material pentru fabricare”",
-"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Pentru rândul {0} în {1}. Pentru a include {2} ratei punctul, randuri {3} De asemenea, trebuie să fie incluse",
-For row {0}: Enter Planned Qty,Pentru rândul {0}: Introduceți cantitatea planificată,
-"For {0}, only credit accounts can be linked against another debit entry","Pentru {0}, numai conturi de credit poate fi legat de o altă intrare în debit",
-"For {0}, only debit accounts can be linked against another credit entry","Pentru {0}, numai conturi de debit poate fi legat de o altă intrare în credit",
-Forum Activity,Activitatea Forumului,
-Free item code is not selected,Codul gratuit al articolului nu este selectat,
-Freight and Forwarding Charges,Incarcatura și Taxe de Expediere,
-Frequency,Frecvență,
-Friday,Vineri,
-From,De la,
-From Address 1,De la adresa 1,
-From Address 2,Din adresa 2,
-From Currency and To Currency cannot be same,Din Valuta și In Valuta nu pot fi identice,
-From Date and To Date lie in different Fiscal Year,De la data și până la data se află în anul fiscal diferit,
-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,Din Data trebuie să fie anterioara Pana la Data,
-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 Date {0} cannot be after employee's relieving Date {1},De la data {0} nu poate fi după data eliberării angajatului {1},
-From Date {0} cannot be before employee's joining Date {1},De la data {0} nu poate fi înainte de data de îmbarcare a angajatului {1},
-From Datetime,De la Datetime,
-From Delivery Note,Din Nota de livrare,
-From Fiscal Year,Din anul fiscal,
-From GSTIN,De la GSTIN,
-From Party Name,De la numele partidului,
-From Pin Code,Din codul PIN,
-From Place,De la loc,
-From Range has to be less than To Range,Din Gama trebuie să fie mai mică de la gama,
-From State,Din stat,
-From Time,Din Time,
-From Time Should Be Less Than To Time,Din timp ar trebui să fie mai puțin decât timpul,
-From Time cannot be greater than To Time.,Din Timpul nu poate fi mai mare decât în timp.,
-"From a supplier under composition scheme, Exempt and Nil rated","De la un furnizor în regim de compoziție, Exempt și Nil au evaluat",
-From and To dates required,Datele De La și Pana La necesare,
-From date can not be less than employee's joining date,De la data nu poate fi mai mică decât data angajării angajatului,
-From value must be less than to value in row {0},Din valoare trebuie să fie mai mică decat in valoare pentru inregistrarea {0},
-From {0} | {1} {2},De la {0} | {1} {2},
-Fuel Price,Preț de combustibil,
-Fuel Qty,combustibil Cantitate,
-Fulfillment,Împlinire,
-Full,Deplin,
-Full Name,Nume complet,
-Full-time,Permanent,
-Fully Depreciated,Depreciata pe deplin,
-Furnitures and Fixtures,Furnitures și Programe,
-"Further accounts can be made under Groups, but entries can be made against non-Groups","Conturile suplimentare pot fi făcute sub Groups, dar intrările pot fi făcute împotriva non-Grupuri",
-Further cost centers can be made under Groups but entries can be made against non-Groups,"Centre de costuri pot fi realizate în grupuri, dar intrările pot fi făcute împotriva non-Grupuri",
-Further nodes can be only created under 'Group' type nodes,Noduri suplimentare pot fi create numai în noduri de tip 'Grup',
-Future dates not allowed,Datele viitoare nu sunt permise,
-GSTIN,GSTIN,
-GSTR3B-Form,GSTR3B-Form,
-Gain/Loss on Asset Disposal,Câștigul / Pierdere de eliminare a activelor,
-Gantt Chart,Diagrama Gantt,
-Gantt chart of all tasks.,Diagrama Gantt a tuturor sarcinilor.,
-Gender,Sex,
-General,General,
-General Ledger,Registru Contabil General,
-Generate Material Requests (MRP) and Work Orders.,Generează cereri de material (MRP) și comenzi de lucru.,
-Generate Secret,Generați secret,
-Get Details From Declaration,Obțineți detalii din declarație,
-Get Employees,Obțineți angajați,
-Get Invocies,Obțineți invocări,
-Get Invoices,Obțineți facturi,
-Get Invoices based on Filters,Obțineți facturi bazate pe filtre,
-Get Items from BOM,Obține articole din FDM,
-Get Items from Healthcare Services,Obțineți articole din serviciile de asistență medicală,
-Get Items from Prescriptions,Obțineți articole din prescripții,
-Get Items from Product Bundle,Obține elemente din Bundle produse,
-Get Suppliers,Obțineți furnizori,
-Get Suppliers By,Obțineți furnizori prin,
-Get Updates,Obțineți actualizări,
-Get customers from,Obțineți clienți de la,
-Get from Patient Encounter,Ia de la întâlnirea cu pacienții,
-Getting Started,Noțiuni de bază,
-GitHub Sync ID,ID-ul de sincronizare GitHub,
-Global settings for all manufacturing processes.,Setările globale pentru toate procesele de producție.,
-Go to the Desktop and start using ERPNext,Du-te la desktop și începe să utilizați ERPNext,
-GoCardless SEPA Mandate,GoCardless Mandatul SEPA,
-GoCardless payment gateway settings,Setările gateway-ului de plată GoCardless,
-Goal and Procedure,Obiectivul și procedura,
-Goals cannot be empty,Obiectivele nu poate fi gol,
-Goods In Transit,Bunuri în tranzit,
-Goods Transferred,Mărfuri transferate,
-Goods and Services Tax (GST India),Mărfuri și servicii fiscale (GST India),
-Goods are already received against the outward entry {0},Mărfurile sunt deja primite cu intrarea exterioară {0},
-Government,Guvern,
-Grand Total,Total general,
-Grant,Acorda,
-Grant Application,Cerere de finanțare nerambursabilă,
-Grant Leaves,Grant Frunze,
-Grant information.,Acordați informații.,
-Grocery,Băcănie,
-Gross Pay,Plata Bruta,
-Gross Profit,Profit brut,
-Gross Profit %,Profit Brut%,
-Gross Profit / Loss,Profit brut / Pierdere,
-Gross Purchase Amount,Sumă brută Cumpărare,
-Gross Purchase Amount is mandatory,Valoarea brută Achiziția este obligatorie,
-Group by Account,Grup in functie de Cont,
-Group by Party,Grup după partid,
-Group by Voucher,Grup in functie de Voucher,
-Group by Voucher (Consolidated),Grup după Voucher (Consolidat),
-Group node warehouse is not allowed to select for transactions,depozit nod grup nu este permis să selecteze pentru tranzacții,
-Group to Non-Group,Grup non-grup,
-Group your students in batches,Grupa elevii în loturi,
-Groups,Grupuri,
-Guardian1 Email ID,Codul de e-mail al Guardian1,
-Guardian1 Mobile No,Guardian1 mobil nr,
-Guardian1 Name,Nume Guardian1,
-Guardian2 Email ID,Codul de e-mail Guardian2,
-Guardian2 Mobile No,Guardian2 mobil nr,
-Guardian2 Name,Nume Guardian2,
-Guest,Oaspete,
-HR Manager,Manager Resurse Umane,
-HSN,HSN,
-HSN/SAC,HSN / SAC,
-Half Day,Jumătate de zi,
-Half Day Date is mandatory,Data semestrului este obligatorie,
-Half Day Date should be between From Date and To Date,Jumătate Data zi ar trebui să fie între De la data si pana in prezent,
-Half Day Date should be in between Work From Date and Work End Date,Data de la jumătate de zi ar trebui să se afle între Data de lucru și Data de terminare a lucrului,
-Half Yearly,Semestrial,
-Half day date should be in between from date and to date,Data de la jumătate de zi ar trebui să fie între data și data,
-Half-Yearly,Semestrial,
-Hardware,Hardware,
-Head of Marketing and Sales,Director de Marketing și Vânzări,
-Health Care,Servicii de Sanatate,
-Healthcare,Sănătate,
-Healthcare (beta),Servicii medicale (beta),
-Healthcare Practitioner,Medicul de îngrijire medicală,
-Healthcare Practitioner not available on {0},Medicul de îngrijire medicală nu este disponibil la {0},
-Healthcare Practitioner {0} not available on {1},Medicul de îngrijire medicală {0} nu este disponibil la {1},
-Healthcare Service Unit,Serviciul de asistență medicală,
-Healthcare Service Unit Tree,Unitatea de servicii de asistență medicală,
-Healthcare Service Unit Type,Tipul unității de servicii medicale,
-Healthcare Services,Servicii pentru sanatate,
-Healthcare Settings,Setări de asistență medicală,
-Hello,buna,
-Help Results for,Rezultate de ajutor pentru,
-High,Ridicat,
-High Sensitivity,Sensibilitate crescută,
-Hold,Păstrarea / Ţinerea / Deţinerea,
-Hold Invoice,Rețineți factura,
-Holiday,Vacanţă,
-Holiday List,Lista de vacanță,
-Hotel Rooms of type {0} are unavailable on {1},Camerele Hotel de tip {0} nu sunt disponibile în {1},
-Hotels,Hoteluri,
-Hourly,ore,
-Hours,ore,
-House rent paid days overlapping with {0},Chirie de casă zile plătite care se suprapun cu {0},
-House rented dates required for exemption calculation,Datele de închiriat pentru casa cerute pentru calcularea scutirii,
-House rented dates should be atleast 15 days apart,Căminul de închiriat al casei trebuie să fie la cel puțin 15 zile,
-How Pricing Rule is applied?,Cum se aplică regula pret?,
-Hub Category,Categorie Hub,
-Hub Sync ID,Hub ID de sincronizare,
-Human Resource,Resurse umane,
-Human Resources,Resurse umane,
-IFSC Code,Codul IFSC,
-IGST Amount,Suma IGST,
-IP Address,Adresa IP,
-ITC Available (whether in full op part),ITC Disponibil (fie în opțiune integrală),
-ITC Reversed,ITC inversat,
-Identifying Decision Makers,Identificarea factorilor de decizie,
-"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)","Dacă este bifată opțiunea Auto Opt In, clienții vor fi conectați automat la programul de loialitate respectiv (la salvare)",
-"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 selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Dacă regula de preț este selectată pentru &quot;Rate&quot;, va suprascrie lista de prețuri. Tarifarea tarifului Rata de rată este rata finală, deci nu trebuie să aplicați nici o reducere suplimentară. Prin urmare, în tranzacții cum ar fi Comandă de Vânzare, Comandă de Achiziție etc, va fi extrasă în câmpul &quot;Rată&quot;, mai degrabă decât în câmpul &quot;Rata Prețurilor&quot;.",
-"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 două sau mai multe reguli de stabilire a prețurilor sunt găsite bazează pe condițiile de mai sus, se aplică prioritate. Prioritatea este un număr între 0 și 20 în timp ce valoarea implicită este zero (gol). Numărul mai mare înseamnă că va avea prioritate în cazul în care există mai multe norme de stabilire a prețurilor, cu aceleași condiții.",
-"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.","Dacă expiră nelimitat pentru Punctele de loialitate, păstrați Durata de expirare goală sau 0.",
-"If you have any questions, please get back to us.","Dacă aveți întrebări, vă rugăm să ne întoarcem la noi.",
-Ignore Existing Ordered Qty,Ignorați cantitatea comandată existentă,
-Image,Imagine,
-Image View,Imagine Vizualizare,
-Import Data,Importați date,
-Import Day Book Data,Importați datele cărții de zi,
-Import Log,Import Conectare,
-Import Master Data,Importați datele de bază,
-Import in Bulk,Importare în masă,
-Import of goods,Importul de bunuri,
-Import of services,Importul serviciilor,
-Importing Items and UOMs,Importarea de articole și UOM-uri,
-Importing Parties and Addresses,Importarea părților și adreselor,
-In Maintenance,În Mentenanță,
-In Production,In productie,
-In Qty,În Cantitate,
-In Stock Qty,În stoc Cantitate,
-In Stock: ,In stoc:,
-In Value,În valoare,
-"In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent","În cazul unui program cu mai multe niveluri, Clienții vor fi automat alocați nivelului respectiv în funcție de cheltuielile efectuate",
-Inactive,Inactiv,
-Incentives,stimulente,
-Include Default Book Entries,Includeți intrări implicite în cărți,
-Include Exploded Items,Includeți articole explodate,
-Include POS Transactions,Includeți tranzacțiile POS,
-Include UOM,Includeți UOM,
-Included in Gross Profit,Inclus în Profitul brut,
-Income,Venit,
-Income Account,Contul de venit,
-Income Tax,Impozit pe venit,
-Incoming,Primite,
-Incoming Rate,Rate 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.,
-Increment cannot be 0,Creștere nu poate fi 0,
-Increment for Attribute {0} cannot be 0,Creștere pentru Atribut {0} nu poate fi 0,
-Indirect Expenses,Cheltuieli indirecte,
-Indirect Income,Venituri indirecte,
-Individual,Individual,
-Ineligible ITC,ITC neeligibil,
-Initiated,Iniţiat,
-Inpatient Record,Înregistrări de pacienți,
-Insert,Introduceți,
-Installation Note,Instalare Notă,
-Installation Note {0} has already been submitted,Instalarea Nota {0} a fost deja prezentat,
-Installation date cannot be before delivery date for Item {0},Data de instalare nu poate fi înainte de data de livrare pentru postul {0},
-Installing presets,Instalarea presetărilor,
-Institute Abbreviation,Institutul Abreviere,
-Institute Name,Numele Institutului,
-Instructor,Instructor,
-Insufficient Stock,Stoc insuficient,
-Insurance Start date should be less than Insurance End date,Asigurare Data de pornire ar trebui să fie mai mică de asigurare Data terminării,
-Integrated Tax,Impozit integrat,
-Inter-State Supplies,Consumabile inter-statale,
-Interest Amount,Suma Dobânda,
-Interests,interese,
-Intern,interna,
-Internet Publishing,Editura Internet,
-Intra-State Supplies,Furnizori intra-statale,
-Introduction,Introducere,
-Invalid Attribute,Atribut nevalid,
-Invalid Blanket Order for the selected Customer and Item,Comanda nevalabilă pentru client și element selectat,
-Invalid Company for Inter Company Transaction.,Companie nevalidă pentru tranzacția inter companie.,
-Invalid GSTIN! A GSTIN must have 15 characters.,GSTIN nevalid! Un GSTIN trebuie să aibă 15 caractere.,
-Invalid GSTIN! First 2 digits of GSTIN should match with State number {0}.,GSTIN nevalid! Primele 2 cifre ale GSTIN ar trebui să se potrivească cu numărul de stat {0}.,
-Invalid GSTIN! The input you've entered doesn't match the format of GSTIN.,GSTIN nevalid! Intrarea introdusă nu corespunde formatului GSTIN.,
-Invalid Posting Time,Ora nevalidă a postării,
-Invalid attribute {0} {1},atribut nevalid {0} {1},
-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.,
-Invalid reference {0} {1},Referință invalid {0} {1},
-Invalid {0},Invalid {0},
-Invalid {0} for Inter Company Transaction.,Nevalabil {0} pentru tranzacția între companii.,
-Invalid {0}: {1},Invalid {0}: {1},
-Inventory,Inventarierea,
-Investment Banking,Investment Banking,
-Investments,investiţii,
-Invoice,Factură,
-Invoice Created,Factura creată,
-Invoice Discounting,Reducerea facturilor,
-Invoice Patient Registration,Inregistrarea pacientului,
-Invoice Posting Date,Data Postare factură,
-Invoice Type,Tip Factura,
-Invoice already created for all billing hours,Factura deja creată pentru toate orele de facturare,
-Invoice can't be made for zero billing hour,Factura nu poate fi făcută pentru cantitate 0 ore facturabile,
-Invoice {0} no longer exists,Factura {0} nu mai există,
-Invoiced,facturată,
-Invoiced Amount,Sumă facturată,
-Invoices,Facturi,
-Invoices for Costumers.,Facturi pentru clienți.,
-Inward supplies from ISD,Consumabile interioare de la ISD,
-Inward supplies liable to reverse charge (other than 1 & 2 above),Livrări interne susceptibile de încărcare inversă (altele decât 1 și 2 de mai sus),
-Is Active,Este activ,
-Is Default,Este Implicit,
-Is Existing Asset,Este activ existent,
-Is Frozen,Este inghetat,
-Is Group,Is Group,
-Issue,Problema,
-Issue Material,Eliberarea Material,
-Issued,Emis,
-Issues,Probleme,
-It is needed to fetch Item Details.,Este nevoie să-i aducă Detalii despre articol.,
-Item,Obiect,
-Item 1,Postul 1,
-Item 2,Punctul 2,
-Item 3,Punctul 3,
-Item 4,Punctul 4,
-Item 5,Punctul 5,
-Item Cart,Cos,
-Item Code,Cod articol,
-Item Code cannot be changed for Serial No.,Cod articol nu pot fi schimbate pentru Serial No.,
-Item Code required at Row No {0},Cod Articol necesar la inregistrarea Nr. {0},
-Item Description,Descriere Articol,
-Item Group,Grup Articol,
-Item Group Tree,Ramificatie Grup Articole,
-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 Name,Numele articolului,
-Item Price added for {0} in Price List {1},Articol Preț adăugată pentru {0} în lista de prețuri {1},
-"Item Price appears multiple times based on Price List, Supplier/Customer, Currency, Item, UOM, Qty and Dates.","Elementul Preț apare de mai multe ori pe baza listei de prețuri, furnizor / client, valută, element, UOM, cantitate și date.",
-Item Price updated for {0} in Price List {1},Articol Preț actualizat pentru {0} în lista de prețuri {1},
-Item Row {0}: {1} {2} does not exist in above '{1}' table,Rândul {0}: {1} {2} nu există în tabelul de mai sus {1},
-Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Taxa Articol pentru inregistrarea {0} trebuie sa detina un cont de tip Fiscal sau De Venituri sau De Cheltuieli sau Taxabil,
-Item Template,Șablon de șablon,
-Item Variant Settings,Setări pentru variantele de articol,
-Item Variant {0} already exists with same attributes,Postul Varianta {0} există deja cu aceleași atribute,
-Item Variants,Variante Postul,
-Item Variants updated,Variante de articol actualizate,
-Item has variants.,Element are variante.,
-Item must be added using 'Get Items from Purchase Receipts' button,"Postul trebuie să fie adăugate folosind ""obține elemente din Cumpără Încasări"" buton",
-Item valuation rate is recalculated considering landed cost voucher amount,Rata de evaluare Articolul este recalculat în vedere aterizat sumă voucher de cost,
-Item variant {0} exists with same attributes,Postul varianta {0} există cu aceleași atribute,
-Item {0} does not exist,Articolul {0} nu există,
-Item {0} does not exist in the system or has expired,Articolul {0} nu există în sistem sau a expirat,
-Item {0} has already been returned,Articolul {0} a fost deja returnat,
-Item {0} has been disabled,Postul {0} a fost dezactivat,
-Item {0} has reached its end of life on {1},Articolul {0} a ajuns la sfârșitul cliclului sau de viață in {1},
-Item {0} ignored since it is not a stock item,"Element {0} ignorat, deoarece nu este un element de stoc",
-"Item {0} is a template, please select one of its variants","Postul {0} este un șablon, vă rugăm să selectați unul dintre variantele sale",
-Item {0} is cancelled,Articolul {0} este anulat,
-Item {0} is disabled,Postul {0} este dezactivat,
-Item {0} is not a serialized Item,Articolul {0} nu este un articol serializat,
-Item {0} is not a stock Item,Articolul{0} nu este un element de stoc,
-Item {0} is not active or end of life has been reached,Articolul {0} nu este activ sau sfarsitul ciclului sau de viata a fost atins,
-Item {0} is not setup for Serial Nos. Check Item master,Articolul {0} nu este configurat pentru Numerotare Seriala. Verificati Articolul Principal.,
-Item {0} is not setup for Serial Nos. Column must be blank,Articolul {0} nu este configurat pentru Numerotare Seriala. Coloana trebuie să fie vida,
-Item {0} must be a Fixed Asset Item,Postul {0} trebuie să fie un element activ fix,
-Item {0} must be a Sub-contracted Item,Articolul {0} trebuie să fie un Articol Sub-contractat,
-Item {0} must be a non-stock item,Postul {0} trebuie să fie un element de bază non-stoc,
-Item {0} must be a stock Item,Articolul {0} trebuie să fie un Articol de Stoc,
-Item {0} not found,Articolul {0} nu a fost găsit,
-Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Postul {0} nu a fost găsit în &quot;Materii prime furnizate&quot; masă în Comandă {1},
-Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Postul {0}: Cantitate comandat {1} nu poate fi mai mică de cantitate minimă de comandă {2} (definită la punctul).,
-Item: {0} does not exist in the system,Postul: {0} nu există în sistemul,
-Items,Articole,
-Items Filter,Filtrarea elementelor,
-Items and Pricing,Articole și Prețuri,
-Items for Raw Material Request,Articole pentru cererea de materii prime,
-Job Card,Carte de muncă,
-Job Description,Descrierea postului,
-Job Offer,Ofertă de muncă,
-Job card {0} created,Cartea de activitate {0} a fost creată,
-Jobs,Posturi,
-Join,A adera,
-Journal Entries {0} are un-linked,Intrările Jurnal {0} sunt ne-legate,
-Journal Entry,Intrare în jurnal,
-Journal Entry {0} does not have account {1} or already matched against other voucher,Jurnal de intrare {0} nu are cont {1} sau deja comparate cu alte voucher,
-Kanban Board,Consiliul de Kanban,
-Key Reports,Rapoarte cheie,
-LMS Activity,Activitate LMS,
-Lab Test,Test de laborator,
-Lab Test Report,Raport de testare în laborator,
-Lab Test Sample,Test de laborator,
-Lab Test Template,Lab Test Template,
-Lab Test UOM,Laboratorul de testare UOM,
-Lab Tests and Vital Signs,Teste de laborator și semne vitale,
-Lab result datetime cannot be before testing datetime,Rezultatul datetimei de laborator nu poate fi înainte de data testării,
-Lab testing datetime cannot be before collection datetime,Timpul de testare al laboratorului nu poate fi înainte de data de colectare,
-Label,Eticheta,
-Laboratory,Laborator,
-Language Name,Nume limbă,
-Large,Mare,
-Last Communication,Ultima comunicare,
-Last Communication Date,Ultima comunicare,
-Last Name,Nume,
-Last Order Amount,Ultima cantitate,
-Last Order Date,Ultima comandă Data,
-Last Purchase Price,Ultima valoare de cumpărare,
-Last Purchase Rate,Ultima Rate de Cumparare,
-Latest,Ultimul,
-Latest price updated in all BOMs,Ultimul preț actualizat în toate BOM-urile,
-Lead,Pistă,
-Lead Count,Număr Pistă,
-Lead Owner,Proprietar Pistă,
-Lead Owner cannot be same as the Lead,Plumb Proprietarul nu poate fi aceeași ca de plumb,
-Lead Time Days,Timpul in Zile Conducere,
-Lead to Quotation,Pistă către Ofertă,
-"Leads help you get business, add all your contacts and more as your leads","Oportunitati de afaceri ajuta să obțineți, adăugați toate contactele și mai mult ca dvs. conduce",
-Learn,Învăța,
-Leave Approval Notification,Lăsați notificarea de aprobare,
-Leave Blocked,Concediu Blocat,
-Leave Encashment,Lasă încasări,
-Leave Management,Lasă managementul,
-Leave Status Notification,Lăsați notificarea de stare,
-Leave Type,Tip Concediu,
-Leave Type is madatory,Tipul de plecare este madatoriu,
-Leave Type {0} cannot be allocated since it is leave without pay,"Lasă un {0} Tipul nu poate fi alocată, deoarece este în concediu fără plată",
-Leave Type {0} cannot be carry-forwarded,Lasă Tipul {0} nu poate fi transporta-transmise,
-Leave Type {0} is not encashable,Tipul de plecare {0} nu este încasat,
-Leave Without Pay,Concediu Fără Plată,
-Leave and Attendance,Plece și prezență,
-Leave application {0} already exists against the student {1},Lăsați aplicația {0} să existe deja împotriva elevului {1},
-"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Concediu nu poate fi repartizat înainte {0}, ca echilibru concediu a fost deja carry transmise în viitor înregistrarea alocare concediu {1}",
-"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Lasă nu poate fi aplicat / anulata pana la {0}, ca echilibru concediu a fost deja carry transmise în viitor înregistrarea alocare concediu {1}",
-Leave of type {0} cannot be longer than {1},Concediul de tip {0} nu poate dura mai mare de {1},
-Leaves,Frunze,
-Leaves Allocated Successfully for {0},Concedii alocate cu succes pentru {0},
-Leaves has been granted sucessfully,Frunzele au fost acordate cu succes,
-Leaves must be allocated in multiples of 0.5,"Concediile trebuie să fie alocate în multipli de 0.5""",
-Leaves per Year,Frunze pe an,
-Ledger,Registru Contabil,
-Legal,Juridic,
-Legal Expenses,Cheltuieli Juridice,
-Letter Head,Antet Scrisoare,
-Letter Heads for print templates.,Antete de Scrisoare de Sabloane de Imprimare.,
-Level,Nivel,
-Liability,Răspundere,
-License,Licență,
-Lifecycle,Ciclu de viață,
-Limit,Limită,
-Limit Crossed,limita Traversat,
-Link to Material Request,Link la solicitarea materialului,
-List of all share transactions,Lista tuturor tranzacțiilor cu acțiuni,
-List of available Shareholders with folio numbers,Lista Acționarilor disponibili cu numere folio,
-Loading Payment System,Încărcarea sistemului de plată,
-Loan,Împrumut,
-Loan Amount cannot exceed Maximum Loan Amount of {0},Suma creditului nu poate depăși valoarea maximă a împrumutului de {0},
-Loan Application,Cerere de împrumut,
-Loan Management,Managementul împrumuturilor,
-Loan Repayment,Rambursare a creditului,
-Loan Start Date and Loan Period are mandatory to save the Invoice Discounting,Data de început a împrumutului și perioada de împrumut sunt obligatorii pentru a salva reducerea facturilor,
-Loans (Liabilities),Imprumuturi (Raspunderi),
-Loans and Advances (Assets),Împrumuturi și avansuri (active),
-Local,Local,
-Log,Buturuga,
-Logs for maintaining sms delivery status,Busteni pentru menținerea statutului de livrare sms,
-Lost,Pierdut,
-Lost Reasons,Motivele pierdute,
-Low,Scăzut,
-Low Sensitivity,Sensibilitate scăzută,
-Lower Income,Micsoreaza Venit,
-Loyalty Amount,Suma de loialitate,
-Loyalty Point Entry,Punct de loialitate,
-Loyalty Points,Puncte de loialitate,
-"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Punctele de loialitate vor fi calculate din suma cheltuită (prin factura de vânzare), pe baza factorului de colectare menționat.",
-Loyalty Points: {0},Puncte de fidelitate: {0},
-Loyalty Program,Program de fidelizare,
-Main,Principal,
-Maintenance,Mentenanţă,
-Maintenance Log,Jurnal Mentenanță,
-Maintenance Manager,Manager Mentenanță,
-Maintenance Schedule,Program Mentenanță,
-Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Programul de Mentenanta nu este generat pentru toate articolele. Vă rugăm să faceți clic pe 'Generare Program',
-Maintenance Schedule {0} exists against {1},Planul de Mentenanță {0} există împotriva {1},
-Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Programul de Mentenanță{0} trebuie anulat înainte de a anula această Comandă de Vânzări,
-Maintenance Status has to be Cancelled or Completed to Submit,Starea de întreținere trebuie anulată sau finalizată pentru a fi trimisă,
-Maintenance User,Întreținere utilizator,
-Maintenance Visit,Vizită Mentenanță,
-Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Vizita de Mentenanță {0} trebuie să fie anulată înainte de a anula această Comandă de Vânzări,
-Maintenance start date can not be before delivery date for Serial No {0},Data de Incepere a Mentenantei nu poate fi anterioara datei de livrare aferent de Nr. de Serie {0},
-Make,Realizare,
-Make Payment,Plateste,
-Make project from a template.,Realizați proiectul dintr-un șablon.,
-Making Stock Entries,Efectuarea de stoc Entries,
-Male,Masculin,
-Manage Customer Group Tree.,Gestioneaza Ramificatiile de Group a Clientului.,
-Manage Sales Partners.,Gestionează Parteneri Vânzări,
-Manage Sales Person Tree.,Gestioneaza Ramificatiile Persoanei responsabila cu Vanzarile,
-Manage Territory Tree.,Gestioneaza Ramificatiile Teritoriule.,
-Manage your orders,Gestionează Comenzi,
-Management,Management,
-Manager,Manager,
-Managing Projects,Managementul Proiectelor,
-Managing Subcontracting,Gestionarea Subcontracte,
-Mandatory,Obligatoriu,
-Mandatory field - Academic Year,Domeniu obligatoriu - An universitar,
-Mandatory field - Get Students From,Domeniu obligatoriu - Obțineți elevii de la,
-Mandatory field - Program,Câmp obligatoriu - Program,
-Manufacture,Fabricare,
-Manufacturer,Producător,
-Manufacturer Part Number,Numarul de piesa,
-Manufacturing,Producţie,
-Manufacturing Quantity is mandatory,Cantitatea de fabricație este obligatorie,
-Mapping,Cartografierea,
-Mapping Type,Tipul de tipărire,
-Mark Absent,Mark Absent,
-Mark Attendance,Marchează prezența,
-Mark Half Day,Mark jumatate de zi,
-Mark Present,Mark Prezent,
-Marketing,Marketing,
-Marketing Expenses,Cheltuieli de marketing,
-Marketplace,Piata de desfacere,
-Marketplace Error,Eroare de pe piață,
-Masters,Masterat,
-Match Payments with Invoices,Plățile se potrivesc cu facturi,
-Match non-linked Invoices and Payments.,Potrivesc Facturi non-legate și plăți.,
-Material,Material,
-Material Consumption,Consumul de materiale,
-Material Consumption is not set in Manufacturing Settings.,Consumul de materiale nu este setat în Setări de fabricare.,
-Material Receipt,Primirea de material,
-Material Request,Cerere de material,
-Material Request Date,Cerere de material Data,
-Material Request No,Cerere de material Nu,
-"Material Request not created, as quantity for Raw Materials already available.","Cerere de material nefiind creată, ca cantitate pentru materiile prime deja disponibile.",
-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 to Purchase Order,Cerere de material de cumpărare Ordine,
-Material Request {0} is cancelled or stopped,Cerere de material {0} este anulată sau oprită,
-Material Request {0} submitted.,Cerere de materiale {0} trimisă.,
-Material Transfer,Transfer de material,
-Material Transferred,Material transferat,
-Material to Supplier,Material de Furnizor,
-Max Exemption Amount cannot be greater than maximum exemption amount {0} of Tax Exemption Category {1},Suma maximă de scutire nu poate fi mai mare decât valoarea scutirii maxime {0} din categoria scutirii de impozite {1},
-Max benefits should be greater than zero to dispense benefits,Beneficiile maxime ar trebui să fie mai mari decât zero pentru a renunța la beneficii,
-Max discount allowed for item: {0} is {1}%,Discount maxim permis pentru articol: {0} este {1}%,
-Max: {0},Max: {0},
-Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Probele maxime - {0} pot fi păstrate pentru lotul {1} și articolul {2}.,
-Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Probele maxime - {0} au fost deja reținute pentru lotul {1} și articolul {2} din lotul {3}.,
-Maximum amount eligible for the component {0} exceeds {1},Suma maximă eligibilă pentru componenta {0} depășește {1},
-Maximum benefit amount of component {0} exceeds {1},Suma maximă de beneficii a componentei {0} depășește {1},
-Maximum benefit amount of employee {0} exceeds {1},Suma maximă a beneficiilor angajatului {0} depășește {1},
-Maximum discount for Item {0} is {1}%,Reducerea maximă pentru articolul {0} este {1}%,
-Maximum leave allowed in the leave type {0} is {1},Permisul maxim permis în tipul de concediu {0} este {1},
-Medical,Medical,
-Medical Code,Codul medical,
-Medical Code Standard,Codul medical standard,
-Medical Department,Departamentul medical,
-Medical Record,Fișă medicală,
-Medium,Medie,
-Meeting,Întâlnire,
-Member Activity,Activitatea membrilor,
-Member ID,Membru ID,
-Member Name,Numele membrului,
-Member information.,Informații despre membri.,
-Membership,apartenență,
-Membership Details,Detalii de membru,
-Membership ID,ID-ul de membru,
-Membership Type,Tipul de membru,
-Memebership Details,Detalii de membru,
-Memebership Type Details,Detalii despre tipul de membru,
-Merge,contopi,
-Merge Account,Îmbinare cont,
-Merge with Existing Account,Mergeți cu contul existent,
-"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Fuziune este posibilă numai în cazul în care următoarele proprietăți sunt aceleași în ambele registre. Este Group, Root Type, Company",
-Message Examples,Exemple de mesaje,
-Message Sent,Mesajul a fost trimis,
-Method,Metoda,
-Middle Income,Venituri medii,
-Middle Name,Al doilea nume,
-Middle Name (Optional),Al Doilea Nume (Opțional),
-Min Amt can not be greater than Max Amt,Min Amt nu poate fi mai mare decât Max Amt,
-Min Qty can not be greater than Max Qty,Min Cantitate nu poate fi mai mare decât Max Cantitate,
-Minimum Lead Age (Days),Vârsta minimă de plumb (zile),
-Miscellaneous Expenses,Cheltuieli diverse,
-Missing Currency Exchange Rates for {0},Lipsesc cursuri de schimb valutar pentru {0},
-Missing email template for dispatch. Please set one in Delivery Settings.,Șablonul de e-mail lipsă pentru expediere. Alegeți unul din Setările de livrare.,
-"Missing value for Password, API Key or Shopify URL","Valoare lipsă pentru parola, cheia API sau adresa URL pentru cumpărături",
-Mode of Payment,Modul de plată,
-Mode of Payments,Modul de plată,
-Mode of Transport,Mijloc de transport,
-Mode of Transportation,Mijloc de transport,
-Mode of payment is required to make a payment,Modul de plată este necesară pentru a efectua o plată,
-Model,Model,
-Moderate Sensitivity,Sensibilitate moderată,
-Monday,Luni,
-Monthly,Lunar,
-Monthly Distribution,Distributie lunar,
-Monthly Repayment Amount cannot be greater than Loan Amount,Rambursarea lunară Suma nu poate fi mai mare decât Suma creditului,
-More,Mai mult,
-More Information,Mai multe informatii,
-More than one selection for {0} not allowed,Nu sunt permise mai multe selecții pentru {0},
-More...,Mai Mult...,
-Motion Picture & Video,Motion Picture & Video,
-Move,Mutare,
-Move Item,Postul mutare,
-Multi Currency,Multi valutar,
-Multiple Item prices.,Mai multe prețuri element.,
-Multiple Loyalty Program found for the Customer. Please select manually.,Programul de loialitate multiplă găsit pentru client. Selectați manual.,
-"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Reguli de preturi multiple există cu aceleași criterii, vă rugăm să rezolve conflictul prin atribuirea de prioritate. Reguli de preț: {0}",
-Multiple Variants,Variante multiple,
-Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,ani fiscali multiple exista in data de {0}. Vă rugăm să setați companie în anul fiscal,
-Music,Muzica,
-My Account,Contul Meu,
-Name error: {0},Numele de eroare: {0},
-Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Numele de cont nou. Notă: Vă rugăm să nu creați conturi pentru clienți și furnizori,
-Name or Email is mandatory,Nume sau E-mail este obligatorie,
-Nature Of Supplies,Natura aprovizionării,
-Navigating,Navigarea,
-Needs Analysis,Analiza nevoilor,
-Negative Quantity is not allowed,Nu este permisă cantitate negativă,
-Negative Valuation Rate is not allowed,Negativ Rata de evaluare nu este permis,
-Negotiation/Review,Negocierea / revizuire,
-Net Asset value as on,Valoarea activelor nete pe,
-Net Cash from Financing,Numerar net din Finantare,
-Net Cash from Investing,Numerar net din investiții,
-Net Cash from Operations,Numerar net din operațiuni,
-Net Change in Accounts Payable,Schimbarea net în conturi de plătit,
-Net Change in Accounts Receivable,Schimbarea net în conturile de creanțe,
-Net Change in Cash,Schimbarea net în numerar,
-Net Change in Equity,Schimbarea net în capitaluri proprii,
-Net Change in Fixed Asset,Schimbarea net în active fixe,
-Net Change in Inventory,Schimbarea net în inventar,
-Net ITC Available(A) - (B),ITC net disponibil (A) - (B),
-Net Pay,Plată netă,
-Net Pay cannot be less than 0,Plata netă nu poate fi mai mică decât 0,
-Net Profit,Profit net,
-Net Salary Amount,Valoarea netă a salariului,
-Net Total,Total net,
-Net pay cannot be negative,Salariul net nu poate fi negativ,
-New Account Name,Nume nou cont,
-New Address,Adresa noua,
-New BOM,Nou BOM,
-New Batch ID (Optional),ID-ul lotului nou (opțional),
-New Batch Qty,Numărul nou de loturi,
-New Company,Companie nouă,
-New Cost Center Name,Numele noului centru de cost,
-New Customer Revenue,Noi surse de venit pentru clienți,
-New Customers,clienti noi,
-New Department,Departamentul nou,
-New Employee,Angajat nou,
-New Location,Locație nouă,
-New Quality Procedure,Noua procedură de calitate,
-New Sales Invoice,Adauga factură de vânzări,
-New Sales Person Name,Nume nou Agent 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 Warehouse Name,Nume nou depozit,
-New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Noua limită de credit este mai mică decât valoarea curentă restante pentru client. Limita de credit trebuie să fie atleast {0},
-New task,Sarcina noua,
-New {0} pricing rules are created,Sunt create noi {0} reguli de preț,
-Newsletters,Buletine,
-Newspaper Publishers,Editorii de ziare,
-Next,Următor,
-Next Contact By cannot be same as the Lead Email Address,Următoarea Contact Prin faptul că nu poate fi aceeași cu adresa de e-mail Plumb,
-Next Contact Date cannot be in the past,În continuare Contact Data nu poate fi în trecut,
-Next Steps,Pasii urmatori,
-No Action,Fara actiune,
-No Customers yet!,Nu există clienți încă!,
-No Data,No Data,
-No Delivery Note selected for Customer {},Nu este selectată nicio notificare de livrare pentru client {},
-No Employee Found,Nu a fost găsit angajat,
-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 available for transfer,Nu există elemente disponibile pentru transfer,
-No Items selected for transfer,Nu există elemente selectate pentru transfer,
-No Items to pack,Nu sunt produse în ambalaj,
-No Items with Bill of Materials to Manufacture,Nu există niciun articol cu Lista de materiale pentru fabricarea,
-No Items with Bill of Materials.,Nu există articole cu Bill of Materials.,
-No Permission,Nici o permisiune,
-No Remarks,Nu Observații,
-No Result to submit,Niciun rezultat nu trebuie trimis,
-No Salary Structure assigned for Employee {0} on given date {1},Nu există structură salarială atribuită pentru angajat {0} la data dată {1},
-No Staffing Plans found for this Designation,Nu au fost găsite planuri de personal pentru această desemnare,
-No Student Groups created.,Nu există grupuri create de studenți.,
-No Students in,Nu există studenți în,
-No Tax Withholding data found for the current Fiscal Year.,Nu au fost găsite date privind reținerea fiscală pentru anul fiscal curent.,
-No Work Orders created,Nu au fost create comenzi de lucru,
-No accounting entries for the following warehouses,Nici o intrare contabile pentru următoarele depozite,
-No active or default Salary Structure found for employee {0} for the given dates,Nr Structură activă sau Salariul implicit găsite pentru angajat al {0} pentru datele indicate,
-No contacts with email IDs found.,Nu au fost găsite contacte cu ID-urile de e-mail.,
-No data for this period,Nu există date pentru această perioadă,
-No description given,Nici o descriere dat,
-No employees for the mentioned criteria,Nu există angajați pentru criteriile menționate,
-No gain or loss in the exchange rate,Nu există cheltuieli sau venituri din diferente ale cursului de schimb,
-No items listed,Nu sunt enumerate elemente,
-No items to be received are overdue,Nu sunt întârziate niciun element de primit,
-No material request created,Nu a fost creată nicio solicitare materială,
-No more updates,Nu există mai multe actualizări,
-No of Interactions,Nr de interacțiuni,
-No of Shares,Numărul de acțiuni,
-No pending Material Requests found to link for the given items.,Nu au fost găsite solicitări de material în așteptare pentru link-ul pentru elementele date.,
-No products found,Nu au fost găsite produse,
-No products found.,Nu găsiți produse.,
-No record found,Nu s-au găsit înregistrări,
-No records found in the Invoice table,Nu sunt găsite inregistrari în tabelul de facturi înregistrate,
-No records found in the Payment table,Nu sunt găsite în tabelul de plăți înregistrări,
-No replies from,Nu există răspunsuri de la,
-No salary slip found to submit for the above selected criteria OR salary slip already submitted,Nu s-a găsit nicio corespondență salarială pentru criteriile de mai sus sau salariul deja trimis,
-No tasks,Nu există nicio sarcină,
-No time sheets,Nu există nicio foaie de timp,
-No values,Fără valori,
-No {0} found for Inter Company Transactions.,Nu a fost găsit {0} pentru tranzacțiile Intercompanie.,
-Non GST Inward Supplies,Consumabile interioare non-GST,
-Non Profit,Non-Profit,
-Non Profit (beta),Nonprofit (beta),
-Non-GST outward supplies,Oferte externe non-GST,
-Non-Group to Group,Non-Grup la Grup,
-None,Nici unul,
-None of the items have any change in quantity or value.,Nici unul din elementele au nici o schimbare în cantitate sau de valoare.,
-Nos,nos,
-Not Available,Indisponibil,
-Not Marked,nemarcate,
-Not Paid and Not Delivered,Nu sunt plătite și nu sunt livrate,
-Not Permitted,Nu este permisă,
-Not Started,Neînceput,
-Not active,Nu este activ,
-Not allow to set alternative item for the item {0},Nu permiteți setarea unui element alternativ pentru articolul {0},
-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 {0} blocat,
-Not authroized since {0} exceeds limits,Nu authroized din {0} depășește limitele,
-Not permitted for {0},Nu este permisă {0},
-"Not permitted, configure Lab Test Template as required","Nu este permisă, configurați Șablon de testare Lab așa cum este necesar",
-Not permitted. Please disable the Service Unit Type,Nu sunt acceptate. Dezactivați tipul unității de serviciu,
-Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Notă: Datorită / Reference Data depășește de companie zile de credit client de {0} zi (le),
-Note: Item {0} entered multiple times,Notă: Articolul {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,
-Nothing is included in gross,Nimic nu este inclus în brut,
-Nothing more to show.,Nimic mai mult pentru a arăta.,
-Nothing to change,Nimic de schimbat,
-Notice Period,Perioada de preaviz,
-Notify Customers via Email,Notificați clienții prin e-mail,
-Number,Număr,
-Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Numărul de Deprecieri Booked nu poate fi mai mare decât Număr total de Deprecieri,
-Number of Interaction,Numărul interacțiunii,
-Number of Order,Numărul de comandă,
-"Number of new Account, it will be included in the account name as a prefix","Numărul de cont nou, acesta va fi inclus în numele contului ca prefix",
-"Number of new Cost Center, it will be included in the cost center name as a prefix","Numărul noului Centru de cost, acesta va fi inclus în prefixul centrului de costuri",
-Number of root accounts cannot be less than 4,Numărul de conturi root nu poate fi mai mic de 4,
-Odometer,Contorul de kilometraj,
-Office Equipments,Echipamente de birou,
-Office Maintenance Expenses,Cheltuieli Mentenanță Birou,
-Office Rent,Birou inchiriat,
-On Hold,In asteptare,
-On Net Total,Pe Net Total,
-One customer can be part of only single Loyalty Program.,Un client poate face parte dintr-un singur program de loialitate.,
-Online Auctions,Licitatii online,
-Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Lăsați numai aplicațiile cu statut „Aprobat“ și „Respins“ pot fi depuse,
-"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",În tabelul de mai jos va fi selectat numai Solicitantul studenților cu statutul &quot;Aprobat&quot;.,
-Only users with {0} role can register on Marketplace,Numai utilizatorii cu rolul {0} se pot înregistra pe Marketplace,
-Open BOM {0},Deschideți BOM {0},
-Open Item {0},Deschis Postul {0},
-Open Notifications,Notificări deschise,
-Open Orders,Comenzi deschise,
-Open a new ticket,Deschideți un nou bilet,
-Opening,Deschidere,
-Opening (Cr),Deschidere (Cr),
-Opening (Dr),Deschidere (Dr),
-Opening Accounting Balance,Sold Contabilitate,
-Opening Accumulated Depreciation,Deschidere Amortizarea Acumulate,
-Opening Accumulated Depreciation must be less than equal to {0},Amortizarea de deschidere trebuie să fie mai mică Acumulate decât egală cu {0},
-Opening Balance,Soldul de deschidere,
-Opening Balance Equity,Sold Equity,
-Opening Date and Closing Date should be within same Fiscal Year,Deschiderea și data inchiderii ar trebui să fie în același an fiscal,
-Opening Date should be before Closing Date,"Deschiderea Data ar trebui să fie, înainte de Data inchiderii",
-Opening Entry Journal,Deschiderea Jurnalului de intrare,
-Opening Invoice Creation Tool,Deschiderea Instrumentului de creare a facturilor,
-Opening Invoice Item,Deschidere element factură,
-Opening Invoices,Deschiderea facturilor,
-Opening Invoices Summary,Sumar de deschidere a facturilor,
-Opening Qty,Deschiderea Cantitate,
-Opening Stock,deschidere stoc,
-Opening Stock Balance,Sold Stock,
-Opening Value,Valoarea de deschidere,
-Opening {0} Invoice created,Deschidere {0} Factură creată,
-Operation,Operație,
-Operation Time must be greater than 0 for Operation {0},Funcționarea timp trebuie să fie mai mare decât 0 pentru funcționare {0},
-"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Operațiunea {0} mai mult decât orice ore de lucru disponibile în stație de lucru {1}, descompun operațiunea în mai multe operațiuni",
-Operations,Operatii,
-Operations cannot be left blank,Operații nu poate fi lăsat necompletat,
-Opp Count,Opp Count,
-Opp/Lead %,Opp / Plumb%,
-Opportunities,Oportunități,
-Opportunities by lead source,Oportunități după sursă pistă,
-Opportunity,Oportunitate,
-Opportunity Amount,Oportunitate Sumă,
-Optional Holiday List not set for leave period {0},Lista de vacanță opțională nu este setată pentru perioada de concediu {0},
-"Optional. Sets company's default currency, if not specified.","Opțional. Setează implicit moneda companiei, în cazul în care nu este specificat.",
-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.,
-Options,Optiuni,
-Order Count,Numărătoarea comenzilor,
-Order Entry,Intrare comandă,
-Order Value,Valoarea comenzii,
-Order rescheduled for sync,Ordonată reprogramată pentru sincronizare,
-Order/Quot %,Ordine / Cotare%,
-Ordered,Ordonat,
-Ordered Qty,Ordonat Cantitate,
-"Ordered Qty: Quantity ordered for purchase, but not received.","Comandat Cantitate: Cantitatea comandat pentru cumpărare, dar nu a primit.",
-Orders,Comenzi,
-Orders released for production.,Comenzi lansat pentru producție.,
-Organization,Organizare,
-Organization Name,Numele Organizatiei,
-Other,Altul,
-Other Reports,Alte rapoarte,
-"Other outward supplies(Nil rated,Exempted)","Alte consumabile exterioare (Nil evaluat, scutit)",
-Others,Altel,
-Out Qty,Out Cantitate,
-Out Value,Valoarea afară,
-Out of Order,Scos din uz,
-Outgoing,Trimise,
-Outstanding,remarcabil,
-Outstanding Amount,Remarcabil Suma,
-Outstanding Amt,Impresionant Amt,
-Outstanding Cheques and Deposits to clear,Cecuri restante și pentru a șterge Depozite,
-Outstanding for {0} cannot be less than zero ({1}),Restante pentru {0} nu poate fi mai mică decât zero ({1}),
-Outward taxable supplies(zero rated),Livrări impozabile externe (zero),
-Overdue,întârziat,
-Overlap in scoring between {0} and {1},Suprapunerea punctajului între {0} și {1},
-Overlapping conditions found between:,Condiții se suprapun găsite între:,
-Owner,Proprietar,
-PAN,TIGAIE,
-POS,POS,
-POS Profile,POS Profil,
-POS Profile is required to use Point-of-Sale,Profilul POS este necesar pentru a utiliza Punctul de vânzare,
-POS Profile required to make POS Entry,POS Profil necesare pentru a face POS intrare,
-POS Settings,Setări POS,
-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 Slip,Slip de ambalare,
-Packing Slip(s) cancelled,Slip de ambalare (e) anulate,
-Paid,Plătit,
-Paid Amount,Suma plătită,
-Paid Amount cannot be greater than total negative outstanding amount {0},Suma plătită nu poate fi mai mare decât suma totală negativă restante {0},
-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,
-Paid and Not Delivered,Plătite și nu sunt livrate,
-Parameter,Parametru,
-Parent Item {0} must not be a Stock Item,Postul părinte {0} nu trebuie să fie un articol stoc,
-Parents Teacher Meeting Attendance,Conferința părinților la conferința părintească,
-Part-time,Part-time,
-Partially Depreciated,parțial Depreciata,
-Partially Received,Parțial primite,
-Party,Partener,
-Party Name,Nume partid,
-Party Type,Tip de partid,
-Party Type and Party is mandatory for {0} account,Tipul partidului și partidul este obligatoriu pentru contul {0},
-Party Type is mandatory,Tipul de partid este obligatorie,
-Party is mandatory,Party este obligatorie,
-Password,Parolă,
-Password policy for Salary Slips is not set,Politica de parolă pentru Salarii Slips nu este setată,
-Past Due Date,Data trecută,
-Patient,Rabdator,
-Patient Appointment,Numirea pacientului,
-Patient Encounter,Întâlnirea cu pacienții,
-Patient not found,Pacientul nu a fost găsit,
-Pay Remaining,Plătiți rămase,
-Pay {0} {1},Plătește {0} {1},
-Payable,plătibil,
-Payable Account,Contul furnizori,
-Payable Amount,Sumă plătibilă,
-Payment,Plată,
-Payment Cancelled. Please check your GoCardless Account for more details,Plata anulată. Verificați contul GoCardless pentru mai multe detalii,
-Payment Confirmation,Confirmarea platii,
-Payment Date,Data de plată,
-Payment Days,Zile de plată,
-Payment Document,Documentul de plată,
-Payment Due Date,Data scadentă de plată,
-Payment Entries {0} are un-linked,Intrările de plată {0} sunt nesemnalate legate,
-Payment Entry,Intrare plăţi,
-Payment Entry already exists,Există deja intrare plată,
-Payment Entry has been modified after you pulled it. Please pull it again.,Plata intrare a fost modificat după ce-l tras. Vă rugăm să trage din nou.,
-Payment Entry is already created,Plata Intrarea este deja creat,
-Payment Failed. Please check your GoCardless Account for more details,Plata esuata. Verificați contul GoCardless pentru mai multe detalii,
-Payment Gateway,Gateway de plată,
-"Payment Gateway Account not created, please create one manually.","Plata Gateway Cont nu a fost creată, vă rugăm să creați manual unul.",
-Payment Gateway Name,Numele gateway-ului de plată,
-Payment Mode,Modul de plată,
-Payment Receipt Note,Plată Primirea Note,
-Payment Request,Cerere de plata,
-Payment Request for {0},Solicitare de plată pentru {0},
-Payment Tems,Tems de plată,
-Payment Term,Termen de plata,
-Payment Terms,Termeni de plată,
-Payment Terms Template,Formularul termenilor de plată,
-Payment Terms based on conditions,Termeni de plată în funcție de condiții,
-Payment Type,Tip de plată,
-"Payment Type must be one of Receive, Pay and Internal Transfer","Tipul de plată trebuie să fie unul dintre Primire, Pay și de transfer intern",
-Payment against {0} {1} cannot be greater than Outstanding Amount {2},Plata împotriva {0} {1} nu poate fi mai mare decât Impresionant Suma {2},
-Payment of {0} from {1} to {2},Plata pentru {0} de la {1} la {2},
-Payment request {0} created,Solicitarea de plată {0} a fost creată,
-Payments,Plăți,
-Payroll,stat de plată,
-Payroll Number,Număr de salarizare,
-Payroll Payable,Salarizare plateste,
-Payslip,fluturaș,
-Pending Activities,Activități în curs,
-Pending Amount,În așteptarea Suma,
-Pending Leaves,Frunze în așteptare,
-Pending Qty,Așteptare Cantitate,
-Pending Quantity,Cantitate în așteptare,
-Pending Review,Revizuirea în curs,
-Pending activities for today,Activități în așteptare pentru ziua de azi,
-Pension Funds,Fondurile de pensii,
-Percentage Allocation should be equal to 100%,Alocarea procent ar trebui să fie egală cu 100%,
-Perception Analysis,Analiza percepției,
-Period,Perioada,
-Period Closing Entry,Intrarea Perioada de închidere,
-Period Closing Voucher,Voucher perioadă de închidere,
-Periodicity,Periodicitate,
-Personal Details,Detalii personale,
-Pharmaceutical,Farmaceutic,
-Pharmaceuticals,Produse farmaceutice,
-Physician,Medic,
-Piecework,muncă în acord,
-Pincode,Parola așa,
-Place Of Supply (State/UT),Locul livrării (stat / UT),
-Place Order,Locul de comandă,
-Plan Name,Numele planului,
-Plan for maintenance visits.,Plan pentru vizite de mentenanță.,
-Planned Qty,Planificate Cantitate,
-"Planned Qty: Quantity, for which, Work Order has been raised, but is pending to be manufactured.","Cantitate planificată: cantitatea pentru care a fost ridicată comanda de lucru, dar este în curs de fabricare.",
-Planning,Planificare,
-Plants and Machineries,Plante și mașini,
-Please Set Supplier Group in Buying Settings.,Setați Grupul de furnizori în Setări de cumpărare.,
-Please add a Temporary Opening account in Chart of Accounts,Adăugați un cont de deschidere temporară în Planul de conturi,
-Please add the account to root level Company - ,Vă rugăm să adăugați contul la nivelul companiei la nivel root -,
-Please add the remaining benefits {0} to any of the existing component,Vă rugăm să adăugați beneficiile rămase {0} la oricare dintre componentele existente,
-Please check Multi Currency option to allow accounts with other currency,Vă rugăm să verificați Multi opțiune de valuta pentru a permite conturi cu altă valută,
-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 confirm once you have completed your training,Vă rugăm să confirmați după ce ați terminat pregătirea,
-Please create purchase receipt or purchase invoice for the item {0},Creați factura de cumpărare sau factura de achiziție pentru elementul {0},
-Please define grade for Threshold 0%,Vă rugăm să definiți gradul pentru pragul 0%,
-Please enable Applicable on Booking Actual Expenses,Activați aplicabil pentru cheltuielile curente de rezervare,
-Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,Activați aplicabil la comanda de aprovizionare și aplicabil cheltuielilor curente de rezervare,
-Please enable default incoming account before creating Daily Work Summary Group,Activați contul de intrare implicit înainte de a crea un grup zilnic de lucru,
-Please enable pop-ups,Vă rugăm să activați pop-up-uri,
-Please enter 'Is Subcontracted' as Yes or No,"Va rugam sa introduceti ""este subcontractată"" ca Da sau Nu",
-Please enter API Consumer Key,Introduceți cheia de consum API,
-Please enter API Consumer Secret,Introduceți secretul pentru clienți API,
-Please enter Account for Change Amount,Vă rugăm să introduceți cont pentru Schimbare Sumă,
-Please enter Approving Role or Approving User,Vă rugăm să introduceți Aprobarea Rolul sau aprobarea de utilizare,
-Please enter Cost Center,Va rugam sa introduceti Cost Center,
-Please enter Delivery Date,Introduceți data livrării,
-Please enter Employee Id of this sales person,Vă rugăm să introduceți ID-ul de angajat al acestei persoane de vânzări,
-Please enter Expense Account,Va rugam sa introduceti cont de cheltuieli,
-Please enter Item Code to get Batch Number,Vă rugăm să introduceți codul de articol pentru a obține numărul de lot,
-Please enter Item Code to get batch no,Va rugam sa introduceti codul articol pentru a obține lot nu,
-Please enter Item first,Va rugam sa introduceti Articol primul,
-Please enter Maintaince Details first,Va rugam sa introduceti maintaince detaliile prima,
-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 Preferred Contact Email,Vă rugăm să introduceți preferate Contact E-mail,
-Please enter Production Item first,Va rugam sa introduceti de producție Articol întâi,
-Please enter Purchase Receipt first,Va rugam sa introduceti Primirea achiziția,
-Please enter Receipt Document,Vă rugăm să introduceți Document Primirea,
-Please enter Reference date,Vă rugăm să introduceți data de referință,
-Please enter Repayment Periods,Vă rugăm să introduceți perioada de rambursare,
-Please enter Reqd by Date,Introduceți Reqd după dată,
-Please enter Woocommerce Server URL,Introduceți adresa URL a serverului Woocommerce,
-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 currency in Company Master,Va rugam sa introduceti moneda implicit în Compania de Master,
-Please enter message before sending,Vă rugăm să introduceți mesajul înainte de trimitere,
-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 repayment Amount,Vă rugăm să introduceți Suma de rambursare,
-Please enter valid Financial Year Start and End Dates,Va rugam sa introduceti valabil financiare Anul începe și a termina Perioada,
-Please enter valid email address,Introduceți adresa de e-mail validă,
-Please enter {0} first,Va rugam sa introduceti {0} primul,
-Please fill in all the details to generate Assessment Result.,Vă rugăm să completați toate detaliile pentru a genera rezultatul evaluării.,
-Please identify/create Account (Group) for type - {0},Vă rugăm să identificați / să creați un cont (grup) pentru tipul - {0},
-Please identify/create Account (Ledger) for type - {0},Vă rugăm să identificați / să creați un cont (contabil) pentru tipul - {0},
-Please login as another user to register on Marketplace,Conectați-vă ca alt utilizator pentru a vă înregistra pe Marketplace,
-Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,Vă rugăm să asigurați-vă că într-adevăr să ștergeți toate tranzacțiile pentru această companie. Datele dvs. de bază vor rămâne așa cum este. Această acțiune nu poate fi anulată.,
-Please mention Basic and HRA component in Company,Vă rugăm să menționați componentele de bază și HRA în cadrul companiei,
-Please mention Round Off Account in Company,Vă rugăm să menționați rotunji contul în companie,
-Please mention Round Off Cost Center in Company,Vă rugăm să menționați rotunji Center cost în companie,
-Please mention no of visits required,Vă rugăm să menționați nici de vizite necesare,
-Please mention the Lead Name in Lead {0},Menționați numele de plumb din plumb {0},
-Please pull items from Delivery Note,Vă rugăm să trage elemente de livrare Nota,
-Please register the SIREN number in the company information file,Înregistrați numărul SIREN în fișierul cu informații despre companie,
-Please remove this Invoice {0} from C-Form {1},Vă rugăm să eliminați acest factură {0} de la C-Form {1},
-Please save the patient first,Salvați mai întâi pacientul,
-Please save the report again to rebuild or update,Vă rugăm să salvați raportul din nou pentru a reconstrui sau actualiza,
-"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Vă rugăm să selectați suma alocată, de tip Factură și factură Numărul din atleast rând una",
-Please select Apply Discount On,Vă rugăm să selectați Aplicați Discount On,
-Please select BOM against item {0},Selectați BOM pentru elementul {0},
-Please select BOM for Item in Row {0},Vă rugăm să selectați BOM pentru postul în rândul {0},
-Please select BOM in BOM field for Item {0},Vă rugăm să selectați BOM BOM în domeniu pentru postul {0},
-Please select Category first,Vă rugăm să selectați categoria întâi,
-Please select Charge Type first,Vă rugăm să selectați tipul de taxă în primul rând,
-Please select Company,Vă rugăm să selectați Company,
-Please select Company and Designation,Selectați Companie și desemnare,
-Please select Company and Posting Date to getting entries,Selectați Company and Dateing date pentru a obține înregistrări,
-Please select Company first,Vă rugăm să selectați Company primul,
-Please select Completion Date for Completed Asset Maintenance Log,Selectați Data de încheiere pentru jurnalul de întreținere a activelor finalizat,
-Please select Completion Date for Completed Repair,Selectați Data de finalizare pentru Repararea finalizată,
-Please select Course,Selectați cursul,
-Please select Drug,Selectați Droguri,
-Please select Employee,Selectați Angajat,
-Please select Existing Company for creating Chart of Accounts,Vă rugăm să selectați Companie pentru crearea Existent Plan de conturi,
-Please select Healthcare Service,Selectați Serviciul de asistență medicală,
-"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle",Vă rugăm să selectați postul unde &quot;Este Piesa&quot; este &quot;nu&quot; și &quot;Este punctul de vânzare&quot; este &quot;da&quot; și nu este nici un alt produs Bundle,
-Please select Maintenance Status as Completed or remove Completion Date,Selectați Stare de întreținere ca Completat sau eliminați Data de finalizare,
-Please select Party Type first,Vă rugăm să selectați Party Type primul,
-Please select Patient,Selectați pacientul,
-Please select Patient to get Lab Tests,Selectați pacientul pentru a obține testele de laborator,
-Please select Posting Date before selecting Party,Vă rugăm să selectați Dată postare înainte de a selecta Parte,
-Please select Posting Date first,Vă rugăm să selectați postarea Data primei,
-Please select Price List,Vă rugăm să selectați lista de prețuri,
-Please select Program,Selectați Program,
-Please select Qty against item {0},Selectați Cantitate pentru elementul {0},
-Please select Sample Retention Warehouse in Stock Settings first,Vă rugăm să selectați mai întâi Warehouse de stocare a probelor din Setări stoc,
-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 Student Admission which is mandatory for the paid student applicant,Selectați admiterea studenților care este obligatorie pentru solicitantul studenților plătiți,
-Please select a BOM,Selectați un BOM,
-Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,Selectați un lot pentru articolul {0}. Nu se poate găsi un singur lot care să îndeplinească această cerință,
-Please select a Company,Vă rugăm să selectați o companie,
-Please select a batch,Selectați un lot,
-Please select a csv file,Vă rugăm să selectați un fișier csv,
-Please select a field to edit from numpad,Selectați un câmp de editat din numpad,
-Please select a table,Selectați un tabel,
-Please select a valid Date,Selectați o dată validă,
-Please select a value for {0} quotation_to {1},Vă rugăm să selectați o valoare de {0} {1} quotation_to,
-Please select a warehouse,Te rugăm să selectazi un depozit,
-Please select at least one domain.,Selectați cel puțin un domeniu.,
-Please select correct account,Vă rugăm să selectați contul corect,
-Please select date,Vă rugăm să selectați data,
-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 Company,Selectați compania,
-Please select the Multiple Tier Program type for more than one collection rules.,Selectați tipul de program cu mai multe niveluri pentru mai multe reguli de colectare.,
-Please select the assessment group other than 'All Assessment Groups',Selectați alt grup de evaluare decât &quot;Toate grupurile de evaluare&quot;,
-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 selectați 0} {întâi,
-Please set 'Apply Additional Discount On',Vă rugăm să setați &quot;Aplicați discount suplimentar pe&quot;,
-Please set 'Asset Depreciation Cost Center' in Company {0},Vă rugăm să setați &quot;Activ Center Amortizarea Cost&quot; în companie {0},
-Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Vă rugăm să setați &#39;Gain / Pierdere de cont privind Eliminarea activelor &quot;în companie {0},
-Please set Account in Warehouse {0} or Default Inventory Account in Company {1},Vă rugăm să configurați contul în depozit {0} sau contul implicit de inventar din companie {1},
-Please set B2C Limit in GST Settings.,Setați limita B2C în setările GST.,
-Please set Company,Stabiliți compania,
-Please set Company filter blank if Group By is 'Company',Filtru filtru de companie gol dacă grupul de grup este &quot;companie&quot;,
-Please set Default Payroll Payable Account in Company {0},Vă rugăm să setați Cont Cheltuieli suplimentare salarizare implicit în companie {0},
-Please set Depreciation related Accounts in Asset Category {0} or Company {1},Vă rugăm să setați Conturi aferente amortizării în categoria activelor {0} sau companie {1},
-Please set Email Address,Vă rugăm să setați adresa de e-mail,
-Please set GST Accounts in GST Settings,Vă rugăm să setați Conturi GST în Setări GST,
-Please set Hotel Room Rate on {},Vă rugăm să stabiliți tariful camerei la {},
-Please set Number of Depreciations Booked,Vă rugăm să setați Numărul de Deprecieri rezervat,
-Please set Unrealized Exchange Gain/Loss Account in Company {0},Vă rugăm să setați Contul de Cheltuiala / Venit din diferente de curs valutar in companie {0},
-Please set User ID field in an Employee record to set Employee Role,Vă rugăm să setați câmp ID de utilizator într-o înregistrare angajat să stabilească Angajat rol,
-Please set a default Holiday List for Employee {0} or Company {1},Vă rugăm să setați o valoare implicită Lista de vacanță pentru angajat {0} sau companie {1},
-Please set account in Warehouse {0},Vă rugăm să configurați un cont în Warehouse {0},
-Please set an active menu for Restaurant {0},Vă rugăm să setați un meniu activ pentru Restaurant {0},
-Please set associated account in Tax Withholding Category {0} against Company {1},Vă rugăm să setați contul asociat în categoria de reținere fiscală {0} împotriva companiei {1},
-Please set at least one row in the Taxes and Charges Table,Vă rugăm să setați cel puțin un rând în tabelul Impozite și taxe,
-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 account in Salary Component {0},Vă rugăm să setați contul implicit în Salariu Component {0},
-Please set default customer in Restaurant Settings,Alegeți clientul implicit în Setări restaurant,
-Please set default template for Leave Approval Notification in HR Settings.,Stabiliți șablonul prestabilit pentru notificarea de aprobare de ieșire din setările HR.,
-Please set default template for Leave Status Notification in HR Settings.,Stabiliți șablonul implicit pentru notificarea de stare la ieșire în setările HR.,
-Please set default {0} in Company {1},Vă rugăm să setați implicit {0} în {1} companie,
-Please set filter based on Item or Warehouse,Vă rugăm să setați filtru bazat pe postul sau depozit,
-Please set leave policy for employee {0} in Employee / Grade record,Vă rugăm să stabiliți politica de concediu pentru angajatul {0} în evidența Angajat / Grad,
-Please set recurring after saving,Vă rugăm să setați recurente după salvare,
-Please set the Company,Stabiliți compania,
-Please set the Customer Address,Vă rugăm să setați Adresa Clientului,
-Please set the Date Of Joining for employee {0},Vă rugăm să setați data de îmbarcare pentru angajat {0},
-Please set the Default Cost Center in {0} company.,Alegeți Centrul de cost implicit în compania {0}.,
-Please set the Email ID for the Student to send the Payment Request,Vă rugăm să setați ID-ul de e-mail pentru ca studentul să trimită Solicitarea de plată,
-Please set the Item Code first,Vă rugăm să setați mai întâi Codul elementului,
-Please set the Payment Schedule,Vă rugăm să setați Programul de plată,
-Please set the series to be used.,Setați seria care urmează să fie utilizată.,
-Please set {0} for address {1},Vă rugăm să setați {0} pentru adresa {1},
-Please setup Students under Student Groups,Configurați elevii din grupurile de studenți,
-Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',Vă rugăm să împărtășiți feedback-ul dvs. la antrenament făcând clic pe &quot;Feedback Training&quot; și apoi pe &quot;New&quot;,
-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 a valid 'From Case No.',"Vă rugăm să specificați un valabil ""Din cauza nr""",
-Please specify a valid Row ID for row {0} in table {1},Vă rugăm să specificați un ID rând valabil pentru rând {0} în tabelul {1},
-Please specify at least one attribute in the Attributes table,Vă rugăm să specificați cel puțin un atribut în tabelul Atribute,
-Please specify currency in Company,Vă rugăm să specificați în valută companie,
-Please specify either Quantity or Valuation Rate or both,Vă rugăm să specificați fie Cantitate sau Evaluează evaluare sau ambele,
-Please specify from/to range,Vă rugăm să precizați de la / la gama,
-Please supply the specified items at the best possible rates,Vă rugăm să furnizeze elementele specificate la cele mai bune tarife posibile,
-Please update your status for this training event,Actualizați starea dvs. pentru acest eveniment de instruire,
-Please wait 3 days before resending the reminder.,Așteptați 3 zile înainte de a retrimite mementourile.,
-Point of Sale,Point of Sale,
-Point-of-Sale,Punct-de-Vânzare,
-Point-of-Sale Profile,Profil Punct-de-Vânzare,
-Portal,Portal,
-Portal Settings,Setări portal,
-Possible Supplier,posibil furnizor,
-Postal Expenses,Cheltuieli poștale,
-Posting Date,Dată postare,
-Posting Date cannot be future date,Dată postare nu poate fi data viitoare,
-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.,
-Practitioner Schedule,Programul practicianului,
-Pre Sales,Vânzări pre,
-Preference,Preferinţă,
-Prescribed Procedures,Proceduri prescrise,
-Prescription,Reteta medicala,
-Prescription Dosage,Dozaj de prescripție,
-Prescription Duration,Durata prescrierii,
-Prescriptions,Prescriptiile,
-Present,Prezenta,
-Prev,Anterior,
-Preview,Previzualizați,
-Preview Salary Slip,Previzualizare Salariu alunecare,
-Previous Financial Year is not closed,Exercițiul financiar precedent nu este închis,
-Price,Preț,
-Price List,Lista Prețuri,
-Price List Currency not selected,Lista de pret Valuta nu selectat,
-Price List Rate,Lista de prețuri Rate,
-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 {0} is disabled or does not exist,Listă de prețuri {0} este dezactivat sau nu există,
-Price or product discount slabs are required,Este necesară plăci de reducere a prețului sau a produsului,
-Pricing,Stabilirea pretului,
-Pricing Rule,Regulă de stabilire a prețurilor,
-"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 Rule {0} is updated,Regula prețurilor {0} este actualizată,
-Pricing Rules are further filtered based on quantity.,Regulile de stabilire a prețurilor sunt filtrate în continuare în funcție de cantitate.,
-Primary Address Details,Detalii despre adresa primară,
-Primary Contact Details,Detalii de contact primare,
-Principal Amount,Sumă principală,
-Print Format,Print Format,
-Print IRS 1099 Forms,Tipărire formulare IRS 1099,
-Print Report Card,Print Print Card,
-Print Settings,Setări de imprimare,
-Print and Stationery,Imprimare și articole de papetărie,
-Print settings updated in respective print format,Setările de imprimare actualizate în format de imprimare respectiv,
-Print taxes with zero amount,Imprimă taxele cu suma zero,
-Printing and Branding,Imprimarea și Branding,
-Private Equity,Private Equity,
-Privilege Leave,Privilege concediu,
-Probation,probă,
-Probationary Period,Perioadă de probă,
-Procedure,Procedură,
-Process Day Book Data,Procesați datele despre cartea de zi,
-Process Master Data,Procesați datele de master,
-Processing Chart of Accounts and Parties,Procesarea Graficului de conturi și părți,
-Processing Items and UOMs,Prelucrare elemente și UOM-uri,
-Processing Party Addresses,Prelucrarea adreselor partidului,
-Processing Vouchers,Procesarea voucherelor,
-Procurement,achiziții publice,
-Produced Qty,Cantitate produsă,
-Product,Produs,
-Product Bundle,Bundle produs,
-Product Search,Cauta produse,
-Production,Producţie,
-Production Item,Producția Postul,
-Products,Instrumente,
-Profit and Loss,Profit și pierdere,
-Profit for the year,Profitul anului,
-Program,Program,
-Program in the Fee Structure and Student Group {0} are different.,Programul din structura taxelor și grupul de studenți {0} este diferit.,
-Program {0} does not exist.,Programul {0} nu există.,
-Program: ,Program:,
-Progress % for a task cannot be more than 100.,Progres% pentru o sarcină care nu poate fi mai mare de 100.,
-Project Collaboration Invitation,Colaborare proiect Invitație,
-Project Id,ID-ul proiectului,
-Project Manager,Manager de proiect,
-Project Name,Denumirea proiectului,
-Project Start Date,Data de începere a proiectului,
-Project Status,Status Proiect,
-Project Summary for {0},Rezumatul proiectului pentru {0},
-Project Update.,Actualizarea proiectului.,
-Project Value,Valoare proiect,
-Project activity / task.,Activitatea de proiect / sarcină.,
-Project master.,Maestru proiect.,
-Project-wise data is not available for Quotation,Date proiect-înțelept nu este disponibilă pentru ofertă,
-Projected,Proiectat,
-Projected Qty,Numărul estimat,
-Projected Quantity Formula,Formula de cantitate proiectată,
-Projects,proiecte,
-Property,Proprietate,
-Property already added,Proprietățile deja adăugate,
-Proposal Writing,Propunere de scriere,
-Proposal/Price Quote,Propunere / Citat pret,
-Prospecting,Prospectarea,
-Provisional Profit / Loss (Credit),Profit provizorie / Pierdere (Credit),
-Publications,Publicații,
-Publish Items on Website,Publica Articole pe site-ul,
-Published,Data publicării,
-Publishing,editare,
-Purchase,Cumpărarea,
-Purchase Amount,Suma cumpărată,
-Purchase Date,Data cumpărării,
-Purchase Invoice,Factura de cumpărare,
-Purchase Invoice {0} is already submitted,Factura de cumpărare {0} este deja depusă,
-Purchase Manager,Cumpărare Director,
-Purchase Master Manager,Cumpărare Maestru de Management,
-Purchase Order,Comandă de aprovizionare,
-Purchase Order Amount,Suma comenzii de cumpărare,
-Purchase Order Amount(Company Currency),Suma comenzii de cumpărare (moneda companiei),
-Purchase Order Date,Data comenzii de cumpărare,
-Purchase Order Items not received on time,Elemente de comandă de cumpărare care nu au fost primite la timp,
-Purchase Order number required for Item {0},Număr de comandă de aprovizionare necesare pentru postul {0},
-Purchase Order to Payment,Comandă de aprovizionare de plata,
-Purchase Order {0} is not submitted,Comandă {0} nu este prezentat,
-Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Comenzile de cumpărare nu sunt permise pentru {0} datorită unui punctaj din {1}.,
-Purchase Orders given to Suppliers.,A achiziționa ordine de date Furnizori.,
-Purchase Price List,Cumparare Lista de preturi,
-Purchase Receipt,Primirea de cumpărare,
-Purchase Receipt {0} is not submitted,Primirea de cumpărare {0} nu este prezentat,
-Purchase Tax Template,Achiziționa Format fiscală,
-Purchase User,Cumpărare de utilizare,
-Purchase orders help you plan and follow up on your purchases,Comenzile de aprovizionare vă ajuta să planificați și să urmați pe achizițiile dvs.,
-Purchasing,cumpărare,
-Purpose must be one of {0},Scopul trebuie să fie una dintre {0},
-Qty,Cantitate,
-Qty To Manufacture,Cantitate pentru fabricare,
-Qty Total,Cantitate totală,
-Qty for {0},Cantitate pentru {0},
-Qualification,Calificare,
-Quality,Calitate,
-Quality Action,Acțiune de calitate,
-Quality Goal.,Obiectivul de calitate.,
-Quality Inspection,Inspecție de calitate,
-Quality Inspection: {0} is not submitted for the item: {1} in row {2},Inspecție de calitate: {0} nu este trimis pentru articol: {1} în rândul {2},
-Quality Management,Managementul calității,
-Quality Meeting,Întâlnire de calitate,
-Quality Procedure,Procedura de calitate,
-Quality Procedure.,Procedura de calitate.,
-Quality Review,Evaluarea calității,
-Quantity,Cantitate,
-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 must be less than or equal to {0},Cantitatea trebuie sa fie mai mic sau egal cu {0},
-Quantity must not be more than {0},Cantitatea nu trebuie să fie mai mare de {0},
-Quantity required for Item {0} in row {1},Cantitatea necesară pentru postul {0} în rândul {1},
-Quantity should be greater than 0,Cantitatea trebuie sa fie mai mare decât 0,
-Quantity to Make,Cantitate de făcut,
-Quantity to Manufacture must be greater than 0.,Cantitatea să Fabricare trebuie sa fie mai mare decât 0.,
-Quantity to Produce,Cantitate de produs,
-Quantity to Produce can not be less than Zero,Cantitatea de produs nu poate fi mai mică decât Zero,
-Query Options,Opțiuni de interogare,
-Queued for replacing the BOM. It may take a few minutes.,În așteptare pentru înlocuirea BOM. Ar putea dura câteva minute.,
-Queued for updating latest price in all Bill of Materials. It may take a few minutes.,A intrat în așteptare pentru actualizarea ultimului preț în toate materialele. Ar putea dura câteva minute.,
-Quick Journal Entry,Quick Jurnal de intrare,
-Quot Count,Contele de numere,
-Quot/Lead %,Cota / Plumb%,
-Quotation,Ofertă,
-Quotation {0} is cancelled,Ofertă {0} este anulat,
-Quotation {0} not of type {1},Ofertă {0} nu de tip {1},
-Quotations,Cotațiile,
-"Quotations are proposals, bids you have sent to your customers","Cotațiile sunt propuneri, sumele licitate le-ați trimis clienților dvs.",
-Quotations received from Suppliers.,Cotatiilor primite de la furnizori.,
-Quotations: ,Cotațiile:,
-Quotes to Leads or Customers.,Citate la Oportunitati sau clienți.,
-RFQs are not allowed for {0} due to a scorecard standing of {1},CV-urile nu sunt permise pentru {0} datorită unui punctaj din {1},
-Range,Interval,
-Rate,Rată,
-Rate:,Rată:,
-Rating,evaluare,
-Raw Material,Material brut,
-Raw Materials,Materie prima,
-Raw Materials cannot be blank.,Materii Prime nu poate fi gol.,
-Re-open,Re-deschide,
-Read blog,Citiți blogul,
-Read the ERPNext Manual,Citiți manualul ERPNext,
-Reading Uploaded File,Citind fișierul încărcat,
-Real Estate,Imobiliare,
-Reason For Putting On Hold,Motivul pentru a pune în așteptare,
-Reason for Hold,Motiv pentru reținere,
-Reason for hold: ,Motivul de reținere:,
-Receipt,Chitanţă,
-Receipt document must be submitted,Document primire trebuie să fie depuse,
-Receivable,De încasat,
-Receivable Account,Cont Încasări,
-Received,Primit,
-Received On,Primit la,
-Received Quantity,Cantitate primită,
-Received Stock Entries,Înscrierile primite,
-Receiver List is empty. Please create Receiver List,Receptor Lista goala. Vă rugăm să creați Receiver Lista,
-Recipients,Destinatarii,
-Reconcile,Reconcilierea,
-"Record of all communications of type email, phone, chat, visit, etc.","Înregistrare a tuturor comunicărilor de tip e-mail, telefon, chat, vizita, etc.",
-Records,Înregistrări,
-Redirect URL,Redirecționare URL-ul,
-Ref,Re,
-Ref Date,Ref Data,
-Reference,Referință,
-Reference #{0} dated {1},Reference # {0} din {1},
-Reference Date,Data de referință,
-Reference Doctype must be one of {0},Referința Doctype trebuie să fie una dintre {0},
-Reference Document,Documentul de referință,
-Reference Document Type,Referință Document Type,
-Reference No & Reference Date is required for {0},Nu referință și de referință Data este necesar pentru {0},
-Reference No and Reference Date is mandatory for Bank transaction,De referință nr și de referință Data este obligatorie pentru tranzacție bancară,
-Reference No is mandatory if you entered Reference Date,De referință nu este obligatorie în cazul în care ați introdus Reference Data,
-Reference No.,Numărul de referință,
-Reference Number,Numar de referinta,
-Reference Owner,Proprietar Referință,
-Reference Type,Tipul Referință,
-"Reference: {0}, Item Code: {1} and Customer: {2}","Referință: {0}, Cod articol: {1} și Client: {2}",
-References,Referințe,
-Refresh Token,Actualizează Indicativ,
-Region,Regiune,
-Register,Înregistrare,
-Reject,Respinge,
-Rejected,Respinse,
-Related,Legate de,
-Relation with Guardian1,Relația cu Guardian1,
-Relation with Guardian2,Relația cu Guardian2,
-Release Date,Data eliberării,
-Reload Linked Analysis,Reîncărcați Analiza Legată,
-Remaining,Rămas,
-Remaining Balance,Balanța rămasă,
-Remarks,Remarci,
-Reminder to update GSTIN Sent,Memento pentru actualizarea mesajului GSTIN Trimis,
-Remove item if charges is not applicable to that item,Eliminați element cazul în care costurile nu se aplică în acest element,
-Removed items with no change in quantity or value.,Articole eliminate fară nici o schimbare de cantitate sau  valoare.,
-Reopen,Redeschide,
-Reorder Level,Nivel pentru re-comanda,
-Reorder Qty,Cantitatea de comandat,
-Repeat Customer Revenue,Repetați Venituri Clienți,
-Repeat Customers,Clienții repetate,
-Replace BOM and update latest price in all BOMs,Înlocuiește BOM și actualizează prețul recent în toate BOM-urile,
-Replied,A răspuns:,
-Replies,Răspunsuri,
-Report,Raport,
-Report Builder,Constructor Raport,
-Report Type,Tip Raport,
-Report Type is mandatory,Tip Raport obligatoriu,
-Reports,Rapoarte,
-Reqd By Date,Cerere livrare la data de,
-Reqd Qty,Reqd Cantitate,
-Request for Quotation,Cerere de ofertă,
-Request for Quotations,Cerere de Oferte,
-Request for Raw Materials,Cerere pentru materii prime,
-Request for purchase.,Cerere de achizitie.,
-Request for quotation.,Cerere de ofertă.,
-Requested Qty,Cant. Solicitată,
-"Requested Qty: Quantity requested for purchase, but not ordered.","A solicitat Cantitate: Cantitatea solicitate pentru achiziții, dar nu a ordonat.",
-Requesting Site,Solicitarea site-ului,
-Requesting payment against {0} {1} for amount {2},Se solicita plata contra {0} {1} pentru suma {2},
-Requestor,care a făcut cererea,
-Required On,Cerut pe,
-Required Qty,Cantitate ceruta,
-Required Quantity,Cantitatea necesară,
-Reschedule,Reprogramează,
-Research,Cercetare,
-Research & Development,Cercetare & Dezvoltare,
-Researcher,Cercetător,
-Resend Payment Email,Retrimiteți e-mail-ul de plată,
-Reserve Warehouse,Rezervați Depozitul,
-Reserved Qty,Cant. rezervata,
-Reserved Qty for Production,Cant. rezervata pentru producție,
-Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Cantitate rezervată pentru producție: cantitate de materii prime pentru fabricarea articolelor de fabricație.,
-"Reserved Qty: Quantity ordered for sale, but not delivered.","Rezervate Cantitate: Cantitatea comandat de vânzare, dar nu livrat.",
-Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Depozitul rezervat este obligatoriu pentru articolul {0} din materiile prime furnizate,
-Reserved for manufacturing,Rezervat pentru fabricare,
-Reserved for sale,Rezervat pentru vânzare,
-Reserved for sub contracting,Rezervat pentru subcontractare,
-Resistant,Rezistent,
-Resolve error and upload again.,Rezolvați eroarea și încărcați din nou.,
-Responsibilities,responsabilităţi,
-Rest Of The World,Restul lumii,
-Restart Subscription,Reporniți Abonament,
-Restaurant,Restaurant,
-Result Date,Data rezultatului,
-Result already Submitted,Rezultatul deja trimis,
-Resume,Reluare,
-Retail,Cu amănuntul,
-Retail & Wholesale,Retail & Wholesale,
-Retail Operations,Operațiunile de vânzare cu amănuntul,
-Retained Earnings,Venituri reținute,
-Retention Stock Entry,Reținerea stocului,
-Retention Stock Entry already created or Sample Quantity not provided,Reținerea stocului de stocare deja creată sau Cantitatea de eșantion care nu a fost furnizată,
-Return,Întoarcere,
-Return / Credit Note,Revenire / credit Notă,
-Return / Debit Note,Returnare / debit Notă,
-Returns,Se intoarce,
-Reverse Journal Entry,Intrare în jurnal invers,
-Review Invitation Sent,Examinarea invitației trimisă,
-Review and Action,Revizuire și acțiune,
-Role,Rol,
-Rooms Booked,Camere rezervate,
-Root Company,Companie de rădăcină,
-Root Type,Rădăcină Tip,
-Root Type is mandatory,Rădăcină de tip este obligatorie,
-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,
-Round Off,Rotunji,
-Rounded Total,Rotunjite total,
-Route,Traseu,
-Row # {0}: ,Rând # {0}:,
-Row # {0}: Batch No must be same as {1} {2},Row # {0}: Lot nr trebuie să fie aceeași ca și {1} {2},
-Row # {0}: Cannot return more than {1} for Item {2},Row # {0}: nu se pot întoarce mai mult {1} pentru postul {2},
-Row # {0}: Rate cannot be greater than the rate used in {1} {2},Rândul # {0}: Rata nu poate fi mai mare decât rata folosită în {1} {2},
-Row # {0}: Serial No is mandatory,Row # {0}: Nu serial este obligatorie,
-Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: Serial No {1} nu se potrivește cu {2} {3},
-Row #{0} (Payment Table): Amount must be negative,Rândul # {0} (tabelul de plată): Suma trebuie să fie negativă,
-Row #{0} (Payment Table): Amount must be positive,Rândul # {0} (tabelul de plată): Suma trebuie să fie pozitivă,
-Row #{0}: Account {1} does not belong to company {2},Rândul # {0}: Contul {1} nu aparține companiei {2},
-Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Rândul # {0}: Suma alocată nu poate fi mai mare decât suma rămasă.,
-"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Rând # {0}: {1} activ nu poate fi prezentat, este deja {2}",
-Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,Rândul # {0}: nu se poate seta Rata dacă suma este mai mare decât suma facturată pentru articolul {1}.,
-Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Rând # {0}: Data de lichidare {1} nu poate fi înainte de Cheque Data {2},
-Row #{0}: Duplicate entry in References {1} {2},Rândul # {0}: intrarea duplicat în referințe {1} {2},
-Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Row # {0}: Data livrării așteptată nu poate fi înainte de data comenzii de achiziție,
-Row #{0}: Item added,Rândul # {0}: articol adăugat,
-Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Rând # {0}: Jurnal de intrare {1} nu are cont {2} sau deja compensată împotriva unui alt voucher,
-Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Row # {0}: Nu este permis să schimbe furnizorul ca Comandă există deja,
-Row #{0}: Please set reorder quantity,Row # {0}: Va rugam sa seta cantitatea reordona,
-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}: Qty increased by 1,Rândul # {0}: cantitatea a crescut cu 1,
-Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Rata trebuie să fie aceeași ca și {1}: {2} ({3} / {4}),
-Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Rândul # {0}: Tipul de document de referință trebuie să fie una dintre revendicările de cheltuieli sau intrări în jurnal,
-"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Rând # {0}: Tip document de referință trebuie să fie unul dintre comandă cumparare, factură sau Jurnal de intrare",
-Row #{0}: Rejected Qty can not be entered in Purchase Return,Row # {0}: Respins Cantitate nu pot fi introduse în Purchase Întoarcere,
-Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Row # {0}: Respins Warehouse este obligatorie împotriva postul respins {1},
-Row #{0}: Reqd by Date cannot be before Transaction Date,Rândul # {0}: Reqd by Date nu poate fi înainte de data tranzacției,
-Row #{0}: Set Supplier for item {1},Row # {0}: Set Furnizor de produs {1},
-Row #{0}: Status must be {1} for Invoice Discounting {2},Rândul # {0}: starea trebuie să fie {1} pentru reducerea facturilor {2},
-"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Rândul # {0}: lotul {1} are doar {2} qty. Selectați un alt lot care are {3} qty disponibil sau împărți rândul în mai multe rânduri, pentru a livra / emite din mai multe loturi",
-Row #{0}: Timings conflicts with row {1},Rând # {0}: conflicte timpilor cu rândul {1},
-Row #{0}: {1} can not be negative for item {2},Row # {0}: {1} nu poate fi negativ pentru elementul {2},
-Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Rândul nr {0}: Suma nu poate fi mai mare decât așteptarea Suma împotriva revendicării cheltuieli {1}. În așteptarea Suma este {2},
-Row {0} : Operation is required against the raw material item {1},Rândul {0}: operația este necesară împotriva elementului de materie primă {1},
-Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Rândul {0} # Suma alocată {1} nu poate fi mai mare decât suma nerevendicată {2},
-Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Rândul {0} # Articol {1} nu poate fi transferat mai mult de {2} față de comanda de aprovizionare {3},
-Row {0}# Paid Amount cannot be greater than requested advance amount,Rândul {0} # Suma plătită nu poate fi mai mare decât suma solicitată în avans,
-Row {0}: Activity Type is mandatory.,Rândul {0}: Activitatea de tip este obligatorie.,
-Row {0}: Advance against Customer must be credit,Row {0}: avans Clientul trebuie să fie de credit,
-Row {0}: Advance against Supplier must be debit,Row {0}: Advance împotriva Furnizor trebuie să fie de debit,
-Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Rândul {0}: Suma alocată {1} trebuie să fie mai mic sau egal cu suma de plată de intrare {2},
-Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Rândul {0}: Suma alocată {1} trebuie să fie mai mic sau egal cu factura suma restanta {2},
-Row {0}: An Reorder entry already exists for this warehouse {1},Rând {0}: O intrare de Comandă există deja pentru acest depozit {1},
-Row {0}: Bill of Materials not found for the Item {1},Rândul {0}: Lista de materiale nu a fost găsit pentru elementul {1},
-Row {0}: Conversion Factor is mandatory,Rând {0}: Factorul de conversie este obligatorie,
-Row {0}: Cost center is required for an item {1},Rând {0}: este necesar un centru de cost pentru un element {1},
-Row {0}: Credit entry can not be linked with a {1},Rând {0}: intrare de credit nu poate fi legat de o {1},
-Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Rând {0}: Moneda de BOM # {1} ar trebui să fie egal cu moneda selectată {2},
-Row {0}: Debit entry can not be linked with a {1},Rând {0}: debit de intrare nu poate fi legat de o {1},
-Row {0}: Depreciation Start Date is required,Rând {0}: este necesară începerea amortizării,
-Row {0}: Enter location for the asset item {1},Rând {0}: introduceți locația pentru elementul de activ {1},
-Row {0}: Exchange Rate is mandatory,Row {0}: Cursul de schimb este obligatoriu,
-Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Rând {0}: Valoarea așteptată după viața utilă trebuie să fie mai mică decât suma brută de achiziție,
-Row {0}: From Time and To Time is mandatory.,Rândul {0}: De la timp și de Ora este obligatorie.,
-Row {0}: From Time and To Time of {1} is overlapping with {2},Rândul {0}: De la timp și Ora {1} se suprapune cu {2},
-Row {0}: From time must be less than to time,Rândul {0}: Din timp trebuie să fie mai mic decât în timp,
-Row {0}: Hours value must be greater than zero.,Rândul {0}: Valoarea ore trebuie să fie mai mare decât zero.,
-Row {0}: Invalid reference {1},Rândul {0}: referință invalid {1},
-Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Rând {0}: Parte / conturi nu se potrivește cu {1} / {2} din {3} {4},
-Row {0}: Party Type and Party is required for Receivable / Payable account {1},Row {0}: Partidul Tipul și Partidul este necesar pentru creanțe / cont plateste {1},
-Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Rând {0}: Plata împotriva Vânzări / Ordinului de Procurare ar trebui să fie întotdeauna marcate ca avans,
-Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Rând {0}: Vă rugăm să verificați ""Este Advance"" împotriva Cont {1} dacă aceasta este o intrare în avans.",
-Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,Rândul {0}: Vă rugăm să setați motivul scutirii de taxe în impozitele și taxele de vânzare,
-Row {0}: Please set the Mode of Payment in Payment Schedule,Rândul {0}: Vă rugăm să setați modul de plată în programul de plată,
-Row {0}: Please set the correct code on Mode of Payment {1},Rândul {0}: Vă rugăm să setați codul corect pe Modul de plată {1},
-Row {0}: Qty is mandatory,Rând {0}: Cant este obligatorie,
-Row {0}: Quality Inspection rejected for item {1},Rândul {0}: Inspecția de calitate a fost respinsă pentru articolul {1},
-Row {0}: UOM Conversion Factor is mandatory,Row {0}: Factorul de conversie UOM este obligatorie,
-Row {0}: select the workstation against the operation {1},Rând {0}: selectați stația de lucru pentru operația {1},
-Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Rând {0}: {1} Numerele de serie necesare pentru articolul {2}. Ați oferit {3}.,
-Row {0}: {1} must be greater than 0,Rând {0}: {1} trebuie să fie mai mare de 0,
-Row {0}: {1} {2} does not match with {3},Rând {0}: {1} {2} nu se potrivește cu {3},
-Row {0}:Start Date must be before End Date,Rând {0}: Data începerii trebuie să fie înainte de Data de încheiere,
-Rows with duplicate due dates in other rows were found: {0},Au fost găsite rânduri cu date scadente în alte rânduri: {0},
-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.,
-S.O. No.,SO No.,
-SGST Amount,Suma SGST,
-SO Qty,SO Cantitate,
-Safety Stock,Stoc de siguranta,
-Salary,Salariu,
-Salary Slip ID,ID-ul de salarizare alunecare,
-Salary Slip of employee {0} already created for this period,Platā angajatului {0} deja creat pentru această perioadă,
-Salary Slip of employee {0} already created for time sheet {1},Salariu de alunecare angajat al {0} deja creat pentru foaie de timp {1},
-Salary Slip submitted for period from {0} to {1},Plata salariului trimisă pentru perioada de la {0} la {1},
-Salary Structure Assignment for Employee already exists,Atribuirea structurii salariale pentru angajat există deja,
-Salary Structure Missing,Structura de salarizare lipsă,
-Salary Structure must be submitted before submission of Tax Ememption Declaration,Structura salariului trebuie depusă înainte de depunerea Declarației de eliberare de impozite,
-Salary Structure not found for employee {0} and date {1},Structura salarială nu a fost găsită pentru angajat {0} și data {1},
-Salary Structure should have flexible benefit component(s) to dispense benefit amount,Structura salariilor ar trebui să aibă componente flexibile pentru beneficiu pentru a renunța la suma beneficiilor,
-"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Salariu au fost deja procesate pentru perioada între {0} și {1}, Lăsați perioada de aplicare nu poate fi între acest interval de date.",
-Sales,Vânzări,
-Sales Account,Cont de vanzari,
-Sales Expenses,Cheltuieli de Vânzare,
-Sales Funnel,Pâlnie Vânzări,
-Sales Invoice,Factură de vânzări,
-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 Manager,Director De Vânzări,
-Sales Master Manager,Vânzări Maestru de Management,
-Sales Order,Comandă de vânzări,
-Sales Order Item,Comandă de vânzări Postul,
-Sales Order required for Item {0},Ordinul de vânzări necesar pentru postul {0},
-Sales Order to Payment,Comanda de vânzări la plată,
-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 {1},Comandă de vânzări {0} este {1},
-Sales Orders,Comenzi de Vânzări,
-Sales Partner,Partener de vânzări,
-Sales Pipeline,Conductă de Vânzări,
-Sales Price List,Lista de prețuri de vânzare,
-Sales Return,Vânzări de returnare,
-Sales Summary,Rezumat Vânzări,
-Sales Tax Template,Format impozitul pe vânzări,
-Sales Team,Echipa de vânzări,
-Sales User,Vânzări de utilizare,
-Sales and Returns,Vânzări și returnări,
-Sales campaigns.,Campanii de vânzări.,
-Sales orders are not available for production,Comenzile de vânzări nu sunt disponibile pentru producție,
-Salutation,Salut,
-Same Company is entered more than once,Aceeași societate este înscris de mai multe ori,
-Same item cannot be entered multiple times.,Același articol nu poate fi introdus de mai multe ori.,
-Same supplier has been entered multiple times,Același furnizor a fost introdus de mai multe ori,
-Sample,Exemplu,
-Sample Collection,Colectie de mostre,
-Sample quantity {0} cannot be more than received quantity {1},Cantitatea de probe {0} nu poate fi mai mare decât cantitatea primită {1},
-Sanctioned,consacrat,
-Sanctioned Amount,Sancționate Suma,
-Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sancționat Suma nu poate fi mai mare decât revendicarea Suma în rândul {0}.,
-Sand,Nisip,
-Saturday,Sâmbătă,
-Saved,Salvat,
-Saving {0},Salvarea {0},
-Scan Barcode,Scanează codul de bare,
-Schedule,Program,
-Schedule Admission,Programați admiterea,
-Schedule Course,Curs orar,
-Schedule Date,Program Data,
-Schedule Discharge,Programați descărcarea,
-Scheduled,Programat,
-Scheduled Upto,Programată până,
-"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Programări pentru suprapunerile {0}, doriți să continuați după ce ați sări peste sloturile suprapuse?",
-Score cannot be greater than Maximum Score,Scorul nu poate fi mai mare decât Scorul maxim,
-Score must be less than or equal to 5,Scorul trebuie să fie mai mică sau egală cu 5,
-Scorecards,Scorecardurilor,
-Scrapped,dezmembrate,
-Search,Căutare,
-Search Results,rezultatele cautarii,
-Search Sub Assemblies,Căutare subansambluri,
-"Search by item code, serial number, batch no or barcode","Căutați după codul de articol, numărul de serie, numărul lotului sau codul de bare",
-"Seasonality for setting budgets, targets etc.","Sezonalitatea pentru stabilirea bugetelor, obiective etc.",
-Secret Key,Cheie secreta,
-Secretary,Secretar,
-Section Code,Codul secțiunii,
-Secured Loans,Împrumuturi garantate,
-Securities & Commodity Exchanges,A Valorilor Mobiliare și Burselor de Mărfuri,
-Securities and Deposits,Titluri de valoare și depozite,
-See All Articles,Vezi toate articolele,
-See all open tickets,Vedeți toate biletele deschise,
-See past orders,Vezi comenzile anterioare,
-See past quotations,Vezi citate anterioare,
-Select,Selectează,
-Select Alternate Item,Selectați elementul alternativ,
-Select Attribute Values,Selectați valorile atributelor,
-Select BOM,Selectați BOM,
-Select BOM and Qty for Production,Selectați BOM și Cant pentru producție,
-"Select BOM, Qty and For Warehouse","Selectați BOM, Qty și For Warehouse",
-Select Batch,Selectați lotul,
-Select Batch Numbers,Selectați numerele lotului,
-Select Brand...,Selectați marca ...,
-Select Company,Selectați Companie,
-Select Company...,Selectați compania ...,
-Select Customer,Selectați Client,
-Select Days,Selectați Zile,
-Select Default Supplier,Selectați Furnizor implicit,
-Select DocType,Selectați DocType,
-Select Fiscal Year...,Selectați Anul fiscal ...,
-Select Item (optional),Selectați elementul (opțional),
-Select Items based on Delivery Date,Selectați elementele bazate pe data livrării,
-Select Items to Manufacture,Selectați elementele de Fabricare,
-Select Loyalty Program,Selectați programul de loialitate,
-Select Patient,Selectați pacientul,
-Select Possible Supplier,Selectați Posibil furnizor,
-Select Property,Selectați proprietatea,
-Select Quantity,Selectați Cantitate,
-Select Serial Numbers,Selectați numerele de serie,
-Select Target Warehouse,Selectați Target Warehouse,
-Select Warehouse...,Selectați Depozit ...,
-Select an account to print in account currency,Selectați un cont pentru a imprima în moneda contului,
-Select an employee to get the employee advance.,Selectați un angajat pentru a avansa angajatul.,
-Select at least one value from each of the attributes.,Selectați cel puțin o valoare din fiecare dintre atribute.,
-Select change amount account,cont Selectați suma schimbare,
-Select company first,Selectați mai întâi compania,
-Select students manually for the Activity based Group,Selectați manual elevii pentru grupul bazat pe activități,
-Select the customer or supplier.,Selectați clientul sau furnizorul.,
-Select the nature of your business.,Selectați natura afacerii dumneavoastră.,
-Select the program first,Selectați mai întâi programul,
-Select to add Serial Number.,Selectați pentru a adăuga număr de serie.,
-Select your Domains,Selectați-vă domeniile,
-Selected Price List should have buying and selling fields checked.,Lista de prețuri selectată ar trebui să verifice câmpurile de cumpărare și vânzare.,
-Sell,Vinde,
-Selling,Vânzare,
-Selling Amount,Vanzarea Suma,
-Selling Price List,Listă Prețuri de Vânzare,
-Selling Rate,Rata de vanzare,
-"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 Grant Review Email,Trimiteți e-mailul de examinare a granturilor,
-Send Now,Trimite Acum,
-Send SMS,Trimite SMS,
-Send mass SMS to your contacts,Trimite SMS-uri în masă a persoanelor de contact,
-Sensitivity,Sensibilitate,
-Sent,Trimis,
-Serial No and Batch,Serial și Lot nr,
-Serial No is mandatory for Item {0},Nu serial este obligatorie pentru postul {0},
-Serial No {0} does not belong to Batch {1},Numărul de serie {0} nu aparține lotului {1},
-Serial No {0} does not belong to Delivery Note {1},Serial No {0} nu aparține de 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 belong to any Warehouse,Serial nr {0} nu apartine nici unei Warehouse,
-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 found,Serial nr {0} nu a fost găsit,
-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 Nos Required for Serialized Item {0},Serial nr necesare pentru postul serializat {0},
-Serial Number: {0} is already referenced in Sales Invoice: {1},Numărul de serie: {0} este deja menționat în factura de vânzare: {1},
-Serial Numbers,Numere de serie,
-Serial Numbers in row {0} does not match with Delivery Note,Numerele de serie din rândul {0} nu se potrivesc cu Nota de livrare,
-Serial no {0} has been already returned,Numărul serial {0} nu a fost deja returnat,
-Serial number {0} entered more than once,Număr de serie {0} a intrat de mai multe ori,
-Serialized Inventory,Inventarul serializat,
-Series Updated,Seria Actualizat,
-Series Updated Successfully,Seria Actualizat cu succes,
-Series is mandatory,Seria este obligatorie,
-Series {0} already used in {1},Series {0} folosit deja în {1},
-Service,Servicii,
-Service Expense,Cheltuieli de serviciu,
-Service Level Agreement,Acord privind nivelul serviciilor,
-Service Level Agreement.,Acord privind nivelul serviciilor.,
-Service Level.,Nivel de servicii.,
-Service Stop Date cannot be after Service End Date,Dată de încetare a serviciului nu poate fi după Data de încheiere a serviciului,
-Service Stop Date cannot be before Service Start Date,Data de începere a serviciului nu poate fi înaintea datei de începere a serviciului,
-Services,Servicii,
-"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Seta valorile implicite, cum ar fi Compania, valutar, Current Anul fiscal, etc",
-Set Details,Setați detalii,
-Set New Release Date,Setați noua dată de lansare,
-Set Project and all Tasks to status {0}?,Setați proiectul și toate sarcinile la starea {0}?,
-Set Status,Setați starea,
-Set Tax Rule for shopping cart,Set Regula fiscală pentru coșul de cumpărături,
-Set as Closed,Setați ca închis,
-Set as Completed,Setați ca Finalizat,
-Set as Default,Setat ca implicit,
-Set as Lost,Setați ca Lost,
-Set as Open,Setați ca Deschis,
-Set default inventory account for perpetual inventory,Setați contul inventarului implicit pentru inventarul perpetuu,
-Set this if the customer is a Public Administration company.,Setați acest lucru dacă clientul este o companie de administrare publică.,
-Set {0} in asset category {1} or company {2},Setați {0} în categoria de active {1} sau în companie {2},
-"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Setarea Evenimente la {0}, deoarece angajatul atașat la mai jos de vânzare Persoanele care nu are un ID de utilizator {1}",
-Setting defaults,Setarea valorilor implicite,
-Setting up Email,Configurarea e-mail,
-Setting up Email Account,Configurarea contului de e-mail,
-Setting up Employees,Configurarea angajati,
-Setting up Taxes,Configurarea Impozite,
-Setting up company,Înființarea companiei,
-Settings,Setări,
-"Settings for online shopping cart such as shipping rules, price list etc.","Setări pentru cosul de cumparaturi on-line, cum ar fi normele de transport maritim, lista de preturi, etc.",
-Settings for website homepage,Setările pentru pagina de start site-ul web,
-Settings for website product listing,Setări pentru listarea produselor site-ului web,
-Settled,Stabilit,
-Setup Gateway accounts.,Setup conturi Gateway.,
-Setup SMS gateway settings,Setări de configurare SMS gateway-ul,
-Setup cheque dimensions for printing,Dimensiunile de instalare pentru imprimare de verificare,
-Setup default values for POS Invoices,Configurați valorile implicite pentru facturile POS,
-Setup mode of POS (Online / Offline),Modul de configurare a POS (online / offline),
-Setup your Institute in ERPNext,Configurați-vă Institutul în ERPNext,
-Share Balance,Soldul acțiunilor,
-Share Ledger,Împărțiți Registru Contabil,
-Share Management,Gestiune partajare,
-Share Transfer,Trimiteți transferul,
-Share Type,Tipul de distribuire,
-Shareholder,Acționar,
-Ship To State,Transport către stat,
-Shipments,Transporturile,
-Shipping,Transport,
-Shipping Address,Adresa de livrare,
-"Shipping Address does not have country, which is required for this Shipping Rule","Adresa de expediere nu are țara, care este necesară pentru această regulă de transport",
-Shipping rule only applicable for Buying,Regulă de expediere aplicabilă numai pentru cumpărături,
-Shipping rule only applicable for Selling,Regulă de expediere aplicabilă numai pentru vânzare,
-Shopify Supplier,Furnizor de magazin,
-Shopping Cart,Cosul de cumparaturi,
-Shopping Cart Settings,Setări Cosul de cumparaturi,
-Short Name,Numele scurt,
-Shortage Qty,Lipsă Cantitate,
-Show Completed,Spectacol finalizat,
-Show Cumulative Amount,Afișați suma cumulată,
-Show Employee,Afișați angajatul,
-Show Open,Afișați deschis,
-Show Opening Entries,Afișare intrări de deschidere,
-Show Payment Details,Afișați detaliile de plată,
-Show Return Entries,Afișați înregistrările returnate,
-Show Salary Slip,Afișează Salariu alunecare,
-Show Variant Attributes,Afișați atribute variate,
-Show Variants,Arată Variante,
-Show closed,Afișează închis,
-Show exploded view,Afișați vizualizarea explodată,
-Show only POS,Afișați numai POS,
-Show unclosed fiscal year's P&L balances,Afișați soldurile L P &amp; anul fiscal unclosed lui,
-Show zero values,Afiseaza valorile nule,
-Sick Leave,A concediului medical,
-Silt,Nămol,
-Single Variant,Varianta unică,
-Single unit of an Item.,Unitate unică a unui articol.,
-"Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}","Scăderea listei de alocare pentru următorii angajați, deoarece înregistrările privind alocarea listei există deja împotriva acestora. {0}",
-"Skipping Salary Structure Assignment for the following employees, as Salary Structure Assignment records already exists against them. {0}","Trecerea alocării structurii salariale pentru următorii angajați, întrucât înregistrările privind structura salariului există deja împotriva lor {0}",
-Slideshow,Slideshow,
-Slots for {0} are not added to the schedule,Sloturile pentru {0} nu sunt adăugate la program,
-Small,Mic,
-Soap & Detergent,Soap & Detergent,
-Software,Software,
-Software Developer,Software Developer,
-Softwares,Softwares,
-Soil compositions do not add up to 100,Compozițiile solului nu adaugă până la 100,
-Sold,Vândut,
-Some emails are invalid,Unele e-mailuri sunt nevalide,
-Some information is missing,Lipsesc unele informații,
-Something went wrong!,Ceva a mers prost!,
-"Sorry, Serial Nos cannot be merged","Ne pare rău, Serial nr nu se pot uni",
-Source,Sursă,
-Source Name,sursa Nume,
-Source Warehouse,Depozit Sursă,
-Source and Target Location cannot be same,Sursa și locația țintă nu pot fi identice,
-Source and target warehouse cannot be same for row {0},Sursă și depozit țintă nu poate fi același pentru rând {0},
-Source and target warehouse must be different,Sursa și depozitul țintă trebuie să fie diferit,
-Source of Funds (Liabilities),Sursa fondurilor (pasive),
-Source warehouse is mandatory for row {0},Depozit sursă este obligatorie pentru rând {0},
-Specified BOM {0} does not exist for Item {1},BOM specificată {0} nu există pentru postul {1},
-Split,Despică,
-Split Batch,Split Lot,
-Split Issue,Emisiune separată,
-Sports,Sport,
-Staffing Plan {0} already exist for designation {1},Planul de personal {0} există deja pentru desemnare {1},
-Standard,Standard,
-Standard Buying,Cumpararea Standard,
-Standard Selling,Vânzarea standard,
-Standard contract terms for Sales or Purchase.,Clauzele contractuale standard pentru vânzări sau de cumpărare.,
-Start Date,Data începerii,
-Start Date of Agreement can't be greater than or equal to End Date.,Data de începere a acordului nu poate fi mai mare sau egală cu data de încheiere.,
-Start Year,Anul de începere,
-"Start and end dates not in a valid Payroll Period, cannot calculate {0}","Datele de început și de încheiere care nu sunt într-o perioadă de salarizare valabilă, nu pot fi calculate {0}",
-"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Datele de începere și de sfârșit nu se află într-o perioadă de salarizare valabilă, nu pot calcula {0}.",
-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},
-Start date should be less than end date for task {0},Data de începere ar trebui să fie mai mică decât data de încheiere pentru sarcina {0},
-Start day is greater than end day in task '{0}',Ziua de început este mai mare decât ziua de sfârșit în sarcina &quot;{0}&quot;,
-Start on,Începe,
-State,Stat,
-State/UT Tax,Impozitul de stat / UT,
-Statement of Account,Extras de cont,
-Status must be one of {0},Statusul trebuie să fie unul din {0},
-Stock,Stoc,
-Stock Adjustment,Ajustarea stoc,
-Stock Analytics,Analytics stoc,
-Stock Assets,Active Stoc,
-Stock Available,Stoc disponibil,
-Stock Balance,Stoc Sold,
-Stock Entries already created for Work Order ,Înregistrări stoc deja create pentru comanda de lucru,
-Stock Entry,Stoc de intrare,
-Stock Entry {0} created,Arhivă de intrare {0} creat,
-Stock Entry {0} is not submitted,Stock intrare {0} nu este prezentat,
-Stock Expenses,Cheltuieli stoc,
-Stock In Hand,Stoc în mână,
-Stock Items,stoc,
-Stock Ledger,Registru Contabil Stocuri,
-Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Stocul Ledger Înscrieri și GL intrările sunt postate pentru selectate Veniturile achiziție,
-Stock Levels,Niveluri stoc,
-Stock Liabilities,Pasive stoc,
-Stock Options,Opțiuni pe acțiuni,
-Stock Qty,Cota stocului,
-Stock Received But Not Billed,"Stock primite, dar nu Considerat",
-Stock Reports,Rapoarte de stoc,
-Stock Summary,Rezumat Stoc,
-Stock Transactions,Tranzacții de stoc,
-Stock UOM,Stoc UOM,
-Stock Value,Valoare stoc,
-Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},echilibru stoc în Serie {0} va deveni negativ {1} pentru postul {2} la Depozitul {3},
-Stock cannot be updated against Delivery Note {0},Stock nu poate fi actualizat împotriva livrare Nota {0},
-Stock cannot be updated against Purchase Receipt {0},Stock nu poate fi actualizat cu confirmare de primire {0} Purchase,
-Stock cannot exist for Item {0} since has variants,Stock nu poate exista pentru postul {0} deoarece are variante,
-Stock transactions before {0} are frozen,Tranzacțiilor bursiere înainte de {0} sunt înghețate,
-Stop,Oprire,
-Stopped,Oprita,
-"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Oprirea comenzii de lucru nu poate fi anulată, deblocați mai întâi pentru a anula",
-Stores,Magazine,
-Structures have been assigned successfully,Structurile au fost alocate cu succes,
-Student,Student,
-Student Activity,Activitatea studenților,
-Student Address,Adresa studenților,
-Student Admissions,Admitere Student,
-Student Attendance,Participarea studenților,
-"Student Batches help you track attendance, assessments and fees for students","Student Sarjele ajută să urmăriți prezență, evaluările și taxele pentru studenți",
-Student Email Address,Adresa de e-mail Student,
-Student Email ID,ID-ul de student e-mail,
-Student Group,Grupul studențesc,
-Student Group Strength,Grupul Forței Studenților,
-Student Group is already updated.,Grupul de studenți este deja actualizat.,
-Student Group: ,Grupul studenților:,
-Student ID,Carnet de student,
-Student ID: ,Carnet de student:,
-Student LMS Activity,Activitatea LMS a studenților,
-Student Mobile No.,Elev mobil Nr,
-Student Name,Numele studentului,
-Student Name: ,Numele studentului:,
-Student Report Card,Student Card de raportare,
-Student is already enrolled.,Student este deja înscris.,
-Student {0} - {1} appears Multiple times in row {2} & {3},Elev {0} - {1} apare ori multiple în rândul {2} &amp; {3},
-Student {0} does not belong to group {1},Studentul {0} nu aparține grupului {1},
-Student {0} exist against student applicant {1},Student {0} există împotriva solicitantului de student {1},
-"Students are at the heart of the system, add all your students","Studenții sunt în centrul sistemului, adăugați toți elevii",
-Sub Assemblies,Sub Assemblies,
-Sub Type,Subtipul,
-Sub-contracting,Sub-contractare,
-Subcontract,subcontract,
-Subject,Subiect,
-Submit,Trimite,
-Submit Proof,Trimiteți dovada,
-Submit Salary Slip,Prezenta Salariul Slip,
-Submit this Work Order for further processing.,Trimiteți acest ordin de lucru pentru o prelucrare ulterioară.,
-Submit this to create the Employee record,Trimiteți acest lucru pentru a crea înregistrarea angajatului,
-Submitting Salary Slips...,Trimiterea buletinelor de salariu ...,
-Subscription,Abonament,
-Subscription Management,Managementul abonamentelor,
-Subscriptions,Abonamente,
-Subtotal,subtotală,
-Successful,De succes,
-Successfully Reconciled,Împăcați cu succes,
-Successfully Set Supplier,Setați cu succes furnizorul,
-Successfully created payment entries,Au fost create intrări de plată cu succes,
-Successfully deleted all transactions related to this company!,Șters cu succes toate tranzacțiile legate de aceasta companie!,
-Sum of Scores of Assessment Criteria needs to be {0}.,Suma Scorurile de criterii de evaluare trebuie să fie {0}.,
-Sum of points for all goals should be 100. It is {0},Suma de puncte pentru toate obiectivele ar trebui să fie 100. este {0},
-Summary,Rezumat,
-Summary for this month and pending activities,Rezumat pentru această lună și activități în așteptarea,
-Summary for this week and pending activities,Rezumat pentru această săptămână și a activităților în curs,
-Sunday,Duminică,
-Suplier,furnizo,
-Supplier,Furnizor,
-Supplier Group,Grupul de furnizori,
-Supplier Group master.,Managerul grupului de furnizori.,
-Supplier Id,Furnizor Id,
-Supplier Invoice Date cannot be greater than Posting Date,Furnizor Data facturii nu poate fi mai mare decât postare Data,
-Supplier Invoice No,Furnizor Factura Nu,
-Supplier Invoice No exists in Purchase Invoice {0},Furnizor Factura nr există în factură Purchase {0},
-Supplier Name,Furnizor Denumire,
-Supplier Part No,Furnizor de piesa,
-Supplier Quotation,Furnizor ofertă,
-Supplier Scorecard,Scorul de performanță al furnizorului,
-Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Furnizor Depozit obligatoriu pentru contractate sub-cumparare Primirea,
-Supplier database.,Baza de date furnizor.,
-Supplier {0} not found in {1},Furnizorul {0} nu a fost găsit în {1},
-Supplier(s),Furnizor (e),
-Supplies made to UIN holders,Materialele furnizate deținătorilor UIN,
-Supplies made to Unregistered Persons,Furnizare pentru persoane neînregistrate,
-Suppliies made to Composition Taxable Persons,Cupluri făcute persoanelor impozabile din componență,
-Supply Type,Tip de aprovizionare,
-Support,Suport,
-Support Analytics,Suport Analytics,
-Support Settings,Setări de sprijin,
-Support Tickets,Bilete de sprijin,
-Support queries from customers.,Interogări de suport din partea clienților.,
-Susceptible,Susceptibil,
-Sync has been temporarily disabled because maximum retries have been exceeded,"Sincronizarea a fost temporar dezactivată, deoarece au fost depășite încercările maxime",
-Syntax error in condition: {0},Eroare de sintaxă în stare: {0},
-Syntax error in formula or condition: {0},Eroare de sintaxă în formulă sau stare: {0},
-System Manager,System Manager,
-TDS Rate %,Rata TDS%,
-Tap items to add them here,Atingeți elementele pentru a le adăuga aici,
-Target,Țintă,
-Target ({}),Țintă ({}),
-Target On,Țintă pe,
-Target Warehouse,Depozit Țintă,
-Target warehouse is mandatory for row {0},Depozit țintă este obligatorie pentru rând {0},
-Task,Sarcină,
-Tasks,Sarcini,
-Tasks have been created for managing the {0} disease (on row {1}),S-au creat sarcini pentru gestionarea bolii {0} (pe rândul {1}),
-Tax,Impozite,
-Tax Assets,Active Fiscale,
-Tax Category,Categoria fiscală,
-Tax Category for overriding tax rates.,Categorie de impozite pentru cote de impozitare superioare.,
-"Tax Category has been changed to ""Total"" because all the Items are non-stock items",Categoria de taxe a fost modificată la &quot;Total&quot; deoarece toate elementele nu sunt elemente stoc,
-Tax ID,ID impozit,
-Tax Id: ,Cod fiscal:,
-Tax Rate,Cota de impozitare,
-Tax Rule Conflicts with {0},Conflicte normă fiscală cu {0},
-Tax Rule for transactions.,Regula de impozit pentru tranzacțiile.,
-Tax Template is mandatory.,Format de impozitare este obligatorie.,
-Tax Withholding rates to be applied on transactions.,Ratele de reținere fiscală aplicabile tranzacțiilor.,
-Tax template for buying transactions.,Șablon taxa pentru tranzacțiilor de cumpărare.,
-Tax template for item tax rates.,Model de impozitare pentru cote de impozit pe articole.,
-Tax template for selling transactions.,Șablon impozit pentru tranzacțiile de vânzare.,
-Taxable Amount,Sumă impozabilă,
-Taxes,Impozite,
-Team Updates,echipa Actualizări,
-Technology,Tehnologia nou-aparuta,
-Telecommunications,Telecomunicații,
-Telephone Expenses,Cheltuieli de telefon,
-Television,Televiziune,
-Template Name,Numele de șablon,
-Template of terms or contract.,Șablon de termeni sau contractului.,
-Templates of supplier scorecard criteria.,Șabloane ale criteriilor privind tabloul de bord al furnizorului.,
-Templates of supplier scorecard variables.,Șabloane ale variabilelor pentru scorurile pentru furnizori.,
-Templates of supplier standings.,Modele de clasificare a furnizorilor.,
-Temporarily on Hold,Temporar în așteptare,
-Temporary,Temporar,
-Temporary Accounts,Conturi temporare,
-Temporary Opening,Deschiderea temporară,
-Terms and Conditions,Termeni si conditii,
-Terms and Conditions Template,Termeni și condiții Format,
-Territory,Teritoriu,
-Test,Test,
-Thank you,Mulțumesc,
-Thank you for your business!,Vă mulțumesc pentru afacerea dvs!,
-The 'From Package No.' field must neither be empty nor it's value less than 1.,"&quot;Din pachetul nr.&quot; câmpul nu trebuie să fie nici gol, nici valoarea lui mai mică decât 1.",
-The Brand,Marca,
-The Item {0} cannot have Batch,Postul {0} nu poate avea Lot,
-The Loyalty Program isn't valid for the selected company,Programul de loialitate nu este valabil pentru compania selectată,
-The Payment Term at row {0} is possibly a duplicate.,"Termenul de plată la rândul {0} este, eventual, un duplicat.",
-The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Pe termen Data de încheiere nu poate fi mai devreme decât Start Termen Data. Vă rugăm să corectați datele și încercați din nou.,
-The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Pe termen Data de încheiere nu poate fi mai târziu de Anul Data de încheiere a anului universitar la care este legat termenul (anului universitar {}). Vă rugăm să corectați datele și încercați din nou.,
-The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Start Termen Data nu poate fi mai devreme decât data Anul de începere a anului universitar la care este legat termenul (anului universitar {}). Vă rugăm să corectați datele și încercați din nou.,
-The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Anul Data de încheiere nu poate fi mai devreme decât data An Start. Vă rugăm să corectați datele și încercați din nou.,
-The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,Valoarea {0} stabilită în această solicitare de plată este diferită de suma calculată a tuturor planurilor de plată: {1}. Asigurați-vă că este corect înainte de a trimite documentul.,
-The day(s) on which you are applying for leave are holidays. You need not apply for leave.,A doua zi (e) pe care se aplica pentru concediu sunt sărbători. Nu trebuie să se aplice pentru concediu.,
-The field From Shareholder cannot be blank,Câmpul From Shareholder nu poate fi gol,
-The field To Shareholder cannot be blank,Câmpul către acționar nu poate fi necompletat,
-The fields From Shareholder and To Shareholder cannot be blank,Câmpurile de la acționar și de la acționar nu pot fi goale,
-The folio numbers are not matching,Numerele folio nu se potrivesc,
-The holiday on {0} is not between From Date and To Date,Vacanta pe {0} nu este între De la data si pana in prezent,
-The name of the institute for which you are setting up this system.,Numele institutului pentru care configurați acest sistem.,
-The name of your company for which you are setting up this system.,Numele companiei dumneavoastră pentru care vă sunt configurarea acestui sistem.,
-The number of shares and the share numbers are inconsistent,Numărul de acțiuni și numerele de acțiuni sunt incoerente,
-The payment gateway account in plan {0} is different from the payment gateway account in this payment request,Contul gateway-ului de plată din plan {0} este diferit de contul gateway-ului de plată din această solicitare de plată,
-The selected BOMs are not for the same item,Cele BOM selectate nu sunt pentru același articol,
-The selected item cannot have Batch,Elementul selectat nu poate avea lot,
-The seller and the buyer cannot be the same,Vânzătorul și cumpărătorul nu pot fi aceleași,
-The shareholder does not belong to this company,Acționarul nu aparține acestei companii,
-The shares already exist,Acțiunile există deja,
-The shares don't exist with the {0},Acțiunile nu există cu {0},
-"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Sarcina a fost considerată ca o lucrare de fond. În cazul în care există vreo problemă cu privire la procesare în fundal, sistemul va adăuga un comentariu despre eroarea la această reconciliere a stocului și va reveni la etapa de proiectare.",
-"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 inconsistencies between the rate, no of shares and the amount calculated","Există neconcordanțe între rata, numărul de acțiuni și suma calculată",
-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 be multiple tiered collection factor based on the total spent. But the conversion factor for redemption will always be same for all the tier.,Pot exista un factor de colectare multiplu diferențiat bazat pe totalul cheltuit. Dar factorul de conversie pentru răscumpărare va fi întotdeauna același pentru toate nivelurile.,
-There can only be 1 Account per Company in {0} {1},Nu poate fi doar un cont per companie în {0} {1},
-"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 no leave period in between {0} and {1},Nu există o perioadă de concediu între {0} și {1},
-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 editat.,
-There isn't any item variant for the selected item,Nu există variante de elemente pentru elementul selectat,
-"There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.","Se pare că există o problemă cu configurația serverului GoCardless. Nu vă faceți griji, în caz de eșec, suma va fi rambursată în cont.",
-There were errors creating Course Schedule,Au apărut erori la crearea programului de curs,
-There were errors.,Au fost erori.,
-This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"Acest post este un șablon și nu pot fi folosite în tranzacții. Atribute articol vor fi copiate pe în variantele cu excepția cazului în este setat ""Nu Copy""",
-This Item is a Variant of {0} (Template).,Acest element este o variantă de {0} (șablon).,
-This Month's Summary,Rezumatul acestei luni,
-This Week's Summary,Rezumat această săptămână,
-This action will stop future billing. Are you sure you want to cancel this subscription?,Această acțiune va opri facturarea viitoare. Sigur doriți să anulați acest abonament?,
-This covers all scorecards tied to this Setup,Aceasta acoperă toate tabelele de scoruri legate de această configurație,
-This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Acest document este peste limita de {0} {1} pentru elementul {4}. Faci un alt {3} împotriva aceleași {2}?,
-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 department and cannot be edited.,Acesta este un departament rădăcină și nu poate fi editat.,
-This is a root healthcare service unit and cannot be edited.,Aceasta este o unitate de asistență medicală rădăcină și nu poate fi editată.,
-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 supplier group and cannot be edited.,Acesta este un grup de furnizori rădăcini și nu poate fi editat.,
-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 based on logs against this Vehicle. See timeline below for details,Aceasta se bazează pe bușteni împotriva acestui vehicul. A se vedea calendarul de mai jos pentru detalii,
-This is based on stock movement. See {0} for details,Aceasta se bazează pe mișcare stoc. A se vedea {0} pentru detalii,
-This is based on the Time Sheets created against this project,Aceasta se bazează pe fișele de pontaj create împotriva acestui proiect,
-This is based on the attendance of this Employee,Aceasta se bazează pe prezența a acestui angajat,
-This is based on the attendance of this Student,Aceasta se bazează pe prezența acestui student,
-This is based on transactions against this Customer. See timeline below for details,Aceasta se bazează pe tranzacțiile împotriva acestui client. A se vedea calendarul de mai jos pentru detalii,
-This is based on transactions against this Healthcare Practitioner.,Aceasta se bazează pe tranzacțiile împotriva acestui medic.,
-This is based on transactions against this Patient. See timeline below for details,Aceasta se bazează pe tranzacțiile împotriva acestui pacient. Consultați linia temporală de mai jos pentru detalii,
-This is based on transactions against this Sales Person. See timeline below for details,Aceasta se bazează pe tranzacțiile efectuate împotriva acestei persoane de vânzări. Consultați linia temporală de mai jos pentru detalii,
-This is based on transactions against this Supplier. See timeline below for details,Aceasta se bazează pe tranzacțiile împotriva acestui furnizor. A se vedea calendarul de mai jos pentru detalii,
-This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Aceasta va trimite salariile de salarizare și va crea înregistrarea de înregistrare în jurnal. Doriți să continuați?,
-This {0} conflicts with {1} for {2} {3},Acest {0} conflicte cu {1} pentru {2} {3},
-Time Sheet for manufacturing.,Fișa de timp pentru fabricație.,
-Time Tracking,Urmărirea timpului,
-"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Slotul de timp a fost anulat, slotul {0} până la {1} suprapune slotul existent {2} până la {3}",
-Time slots added,Au fost adăugate sloturi de timp,
-Time(in mins),Timp (în min),
-Timer,Cronometrul,
-Timer exceeded the given hours.,Timerul a depășit orele date.,
-Timesheet,Pontaj,
-Timesheet for tasks.,Timesheet pentru sarcini.,
-Timesheet {0} is already completed or cancelled,Pontajul {0} este deja finalizat sau anulat,
-Timesheets,pontaje,
-"Timesheets help keep track of time, cost and billing for activites done by your team","Pontaje ajuta să urmăriți timp, costuri și de facturare pentru activitati efectuate de echipa ta",
-Titles for print templates e.g. Proforma Invoice.,"Titluri de șabloane de imprimare, de exemplu proforma Factura.",
-To,La,
-To Address 1,Pentru a adresa 1,
-To Address 2,Pentru a adresa 2,
-To Bill,Pentru a Bill,
-To Date,La Data,
-To Date cannot be before From Date,Până în prezent nu poate fi înainte de data,
-To Date cannot be less than From Date,Data nu poate fi mai mică decât Din data,
-To Date must be greater than From Date,Pentru data trebuie să fie mai mare decât de la data,
-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 Datetime,Pentru a Datetime,
-To Deliver,A livra,
-To Deliver and Bill,Pentru a livra și Bill,
-To Fiscal Year,Anul fiscal,
-To GSTIN,Pentru GSTIN,
-To Party Name,La numele partidului,
-To Pin Code,Pentru a activa codul,
-To Place,A plasa,
-To Receive,A primi,
-To Receive and Bill,Pentru a primi și Bill,
-To State,A afirma,
-To Warehouse,La Depozit,
-To create a Payment Request reference document is required,Pentru a crea un document de referință privind solicitarea de plată este necesar,
-To date can not be equal or less than from date,Până în prezent nu poate fi egală sau mai mică decât de la data,
-To date can not be less than from date,Până în prezent nu poate fi mai mică decât de la data,
-To date can not greater than employee's relieving date,Până în prezent nu poate fi mai mare decât data scutirii angajatului,
-"To filter based on Party, select Party Type first","Pentru a filtra pe baza Party, selectați Party Tip primul",
-"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Pentru a obține cele mai bune din ERPNext, vă recomandăm să luați ceva timp și de ceas aceste filme de ajutor.",
-"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 make Customer based incentive schemes.,Pentru a crea scheme de stimulare bazate pe client.,
-"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 view logs of Loyalty Points assigned to a Customer.,Pentru a vizualiza jurnalele punctelor de loialitate atribuite unui client.,
-To {0},Pentru a {0},
-To {0} | {1} {2},Pentru a {0} | {1} {2},
-Toggle Filters,Comutați filtrele,
-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,Instrumente,
-Total (Credit),Total (Credit),
-Total (Without Tax),Total (fără taxe),
-Total Absent,Raport Absent,
-Total Achieved,Raport Realizat,
-Total Actual,Raport real,
-Total Allocated Leaves,Frunzele totale alocate,
-Total Amount,Suma totală,
-Total Amount Credited,Suma totală creditată,
-Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Taxe totale aplicabile în tabelul de achiziție Chitanță Elementele trebuie să fie la fel ca total impozite și taxe,
-Total Budget,Buget total,
-Total Collected: {0},Totalul colectat: {0},
-Total Commission,Total de Comisie,
-Total Contribution Amount: {0},Suma totală a contribuției: {0},
-Total Credit/ Debit Amount should be same as linked Journal Entry,Suma totală a creditului / debitului ar trebui să fie aceeași cu cea înregistrată în jurnal,
-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 Invoiced Amount,Suma totală facturată,
-Total Leaves,Frunze totale,
-Total Order Considered,Comanda total Considerat,
-Total Order Value,Valoarea totală Comanda,
-Total Outgoing,Raport de ieșire,
-Total Outstanding,Total deosebit,
-Total Outstanding Amount,Total Suma Impresionant,
-Total Outstanding: {0},Total excepție: {0},
-Total Paid Amount,Total Suma plătită,
-Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Suma totală de plată în Planul de Plăți trebuie să fie egală cu Total / Rotunjit,
-Total Payments,Total plăți,
-Total Present,Raport Prezent,
-Total Qty,Raport Cantitate,
-Total Quantity,Cantitatea totala,
-Total Revenue,Raport Venituri,
-Total Student,Student total,
-Total Target,Raport țintă,
-Total Tax,Taxa totală,
-Total Taxable Amount,Sumă impozabilă totală,
-Total Taxable Value,Valoarea impozabilă totală,
-Total Unpaid: {0},Neremunerat totală: {0},
-Total Variance,Raport Variance,
-Total Weightage of all Assessment Criteria must be 100%,Weightage totală a tuturor criteriilor de evaluare trebuie să fie 100%,
-Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),avans total ({0}) împotriva Comanda {1} nu poate fi mai mare decât totalul ({2}),
-Total advance amount cannot be greater than total claimed amount,Suma avansului total nu poate fi mai mare decât suma totală revendicată,
-Total advance amount cannot be greater than total sanctioned amount,Suma avansului total nu poate fi mai mare decât suma totală sancționată,
-Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,Frunzele totale alocate sunt mai multe zile decât alocarea maximă a tipului de concediu {0} pentru angajatul {1} în perioada respectivă,
-Total allocated leaves are more than days in the period,TOTAL frunze alocate sunt mai mult decât zile în perioada,
-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 cannot be zero,Totalul nu poate să fie zero,
-Total contribution percentage should be equal to 100,Procentul total al contribuției ar trebui să fie egal cu 100,
-Total flexible benefit component amount {0} should not be less than max benefits {1},Suma totală a componentelor de beneficii flexibile {0} nu trebuie să fie mai mică decât beneficiile maxime {1},
-Total hours: {0},Numărul total de ore: {0},
-Total leaves allocated is mandatory for Leave Type {0},Numărul total de frunze alocate este obligatoriu pentru Type Leave {0},
-Total working hours should not be greater than max working hours {0},Numărul total de ore de lucru nu trebuie sa fie mai mare de ore de lucru max {0},
-Total {0} ({1}),Total {0} ({1}),
-"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Total {0} pentru toate articolele este zero, poate fi ar trebui să schimbați „Distribuirea cheltuielilor pe baza“",
-Total(Amt),Total (Amt),
-Total(Qty),Total (Cantitate),
-Traceability,Trasabilitate,
-Traceback,Traceback,
-Track Leads by Lead Source.,Urmărește Oportunități după Sursă Oportunitate,
-Training,Pregătire,
-Training Event,Eveniment de formare,
-Training Events,Evenimente de instruire,
-Training Feedback,Feedback formare,
-Training Result,Rezultatul de formare,
-Transaction,Tranzacţie,
-Transaction Date,Data tranzacției,
-Transaction Type,tipul tranzacției,
-Transaction currency must be same as Payment Gateway currency,Moneda de tranzacție trebuie să fie aceeași ca și de plată Gateway monedă,
-Transaction not allowed against stopped Work Order {0},Tranzacția nu este permisă împotriva comenzii de lucru oprita {0},
-Transaction reference no {0} dated {1},de referință al tranzacției nu {0} {1} din,
-Transactions,tranzacţii,
-Transactions can only be deleted by the creator of the Company,Tranzacții pot fi șterse doar de către creatorul Companiei,
-Transfer,Transfer,
-Transfer Material,Material de transfer,
-Transfer Type,Tip de transfer,
-Transfer an asset from one warehouse to another,Se transferă un activ de la un depozit la altul,
-Transfered,transferat,
-Transferred Quantity,Cantitate transferată,
-Transport Receipt Date,Data primirii transportului,
-Transport Receipt No,Primirea transportului nr,
-Transportation,Transport,
-Transporter ID,ID-ul transportatorului,
-Transporter Name,Transporter Nume,
-Travel,Călători,
-Travel Expenses,Cheltuieli de calatorie,
-Tree Type,Arbore Tip,
-Tree of Bill of Materials,Arborele de Bill de materiale,
-Tree of Item Groups.,Arborele de Postul grupuri.,
-Tree of Procedures,Arborele procedurilor,
-Tree of Quality Procedures.,Arborele procedurilor de calitate.,
-Tree of financial Cost Centers.,Tree of centre de cost financiare.,
-Tree of financial accounts.,Arborescentă conturilor financiare.,
-Treshold {0}% appears more than once,Treshold {0}% apare mai mult decât o dată,
-Trial Period End Date Cannot be before Trial Period Start Date,Perioada de încheiere a perioadei de încercare nu poate fi înainte de data începerii perioadei de încercare,
-Trialling,experimentării,
-Type of Business,Tip de afacere,
-Types of activities for Time Logs,Tipuri de activități pentru busteni Timp,
-UOM,UOM,
-UOM Conversion factor is required in row {0},Factor UOM de conversie este necesară în rândul {0},
-UOM coversion factor required for UOM: {0} in Item: {1},Factor coversion UOM UOM necesare pentru: {0} in articol: {1},
-URL,URL-ul,
-Unable to find DocType {0},Nu se poate găsi DocType {0},
-Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Imposibil de găsit rata de schimb pentru {0} până la {1} pentru data cheie {2}. Creați manual un registru de schimb valutar,
-Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Nu se poate găsi scorul începând cu {0}. Trebuie să aveți scoruri în picioare care acoperă între 0 și 100,
-Unable to find variable: ,Imposibil de găsit variabila:,
-Unblock Invoice,Deblocați factura,
-Uncheck all,Deselecteaza tot,
-Unclosed Fiscal Years Profit / Loss (Credit),Unclosed fiscal Ani de Profit / Pierdere (credit),
-Unit,Unitate,
-Unit of Measure,Unitate 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,
-Unknown,Necunoscut,
-Unpaid,Neachitat,
-Unsecured Loans,Creditele negarantate,
-Unsubscribe from this Email Digest,Dezabona de la acest e-mail Digest,
-Unsubscribed,Nesubscrise,
-Until,Până la,
-Unverified Webhook Data,Datele Webhook neconfirmate,
-Update Account Name / Number,Actualizați numele / numărul contului,
-Update Account Number / Name,Actualizați numărul / numele contului,
-Update Cost,Actualizare Cost,
-Update Items,Actualizați elementele,
-Update Print Format,Actualizare Format Print,
-Update Response,Actualizați răspunsul,
-Update bank payment dates with journals.,Actualizați datele de plată bancar cu reviste.,
-Update in progress. It might take a while.,Actualizare în curs. Ar putea dura ceva timp.,
-Update rate as per last purchase,Rata de actualizare ca pe ultima achiziție,
-Update stock must be enable for the purchase invoice {0},Actualizați stocul trebuie să fie activat pentru factura de achiziție {0},
-Updating Variants...,Actualizarea variantelor ...,
-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,
-Use Sandbox,utilizare Sandbox,
-Used Leaves,Frunze utilizate,
-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 Remark,Observație utilizator,
-User has not applied rule on the invoice {0},Utilizatorul nu a aplicat o regulă pentru factură {0},
-User {0} already exists,Utilizatorul {0} există deja,
-User {0} created,Utilizatorul {0} a fost creat,
-User {0} does not exist,Utilizatorul {0} nu există,
-User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Utilizatorul {0} nu are niciun POS profil implicit. Verificați implicit la Rând {1} pentru acest utilizator.,
-User {0} is already assigned to Employee {1},Utilizatorul {0} este deja alocat Angajat {1},
-User {0} is already assigned to Healthcare Practitioner {1},Utilizatorul {0} este deja însărcinat cu medicul de îngrijire medicală {1},
-Users,Utilizatori,
-Utility Expenses,Cheltuieli de utilitate,
-Valid From Date must be lesser than Valid Upto Date.,Valabil din data trebuie să fie mai mică decât valabil până la data.,
-Valid Till,Valabil până la,
-Valid from and valid upto fields are mandatory for the cumulative,Câmpurile valabile și valabile până la acestea sunt obligatorii pentru cumul,
-Valid from date must be less than valid upto date,Valabil de la data trebuie să fie mai mic decât valabil până la data actuală,
-Valid till date cannot be before transaction date,Valabil până la data nu poate fi înainte de data tranzacției,
-Validity,Valabilitate,
-Validity period of this quotation has ended.,Perioada de valabilitate a acestui citat sa încheiat.,
-Valuation Rate,Rata de evaluare,
-Valuation Rate is mandatory if Opening Stock entered,Evaluarea Rata este obligatorie în cazul în care a intrat Deschiderea stoc,
-Valuation type charges can not marked as Inclusive,Taxele de tip evaluare nu poate marcate ca Inclusive,
-Value Or Qty,Valoare sau Cantitate,
-Value Proposition,Propunere de valoare,
-Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Valoare pentru atributul {0} trebuie să fie în intervalul de {1} la {2} în trepte de {3} pentru postul {4},
-Value missing,Valoarea lipsește,
-Value must be between {0} and {1},Valoarea trebuie să fie între {0} și {1},
-"Values of exempt, nil rated and non-GST inward supplies","Valorile livrărilor interne scutite, nule și fără GST",
-Variable,Variabil,
-Variance,variație,
-Variance ({}),Varianță ({}),
-Variant,Variantă,
-Variant Attributes,Atribute Variant,
-Variant Based On cannot be changed,Varianta bazată pe nu poate fi modificată,
-Variant Details Report,Varianta Detalii raport,
-Variant creation has been queued.,Crearea de variante a fost în coada de așteptare.,
-Vehicle Expenses,Cheltuielile pentru vehicule,
-Vehicle No,Vehicul Nici,
-Vehicle Type,Tip de vehicul,
-Vehicle/Bus Number,Numărul vehiculului / autobuzului,
-Venture Capital,Capital de risc,
-View Chart of Accounts,Vezi Diagramă de Conturi,
-View Fees Records,Vizualizați înregistrările de taxe,
-View Form,Formular de vizualizare,
-View Lab Tests,Vizualizați testele de laborator,
-View Leads,Vezi Piste,
-View Ledger,Vezi Registru Contabil,
-View Now,Vizualizează acum,
-View a list of all the help videos,Vizualizați o listă cu toate filmele de ajutor,
-View in Cart,Vizualizare Coș,
-Visit report for maintenance call.,Vizitați raport pentru apel de mentenanță.,
-Visit the forums,Vizitați forumurile,
-Vital Signs,Semnele vitale,
-Volunteer,Voluntar,
-Volunteer Type information.,Informații de tip Voluntar.,
-Volunteer information.,Informații despre voluntari.,
-Voucher #,Voucher #,
-Voucher No,Voletul nr,
-Voucher Type,Tip Voucher,
-WIP Warehouse,WIP Depozit,
-Walk In,Walk In,
-Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Depozitul nu poate fi șters deoarece există intrări in registru contabil stocuri pentru acest depozit.,
-Warehouse cannot be changed for Serial No.,Depozit nu poate fi schimbat pentru Serial No.,
-Warehouse is mandatory,Depozitul este obligatoriu,
-Warehouse is mandatory for stock Item {0} in row {1},Depozitul este obligatoriu pentru articol stoc {0} în rândul {1},
-Warehouse not found in the system,Depozit nu a fost găsit în sistemul,
-"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}","Depozitul necesar la rândul nr. {0}, vă rugăm să setați un depozit implicit pentru elementul {1} pentru companie {2}",
-Warehouse required for stock Item {0},Depozit necesar pentru stoc articol {0},
-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,Depozitul {0} nu există,
-"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Warehouse {0} nu este conectat la niciun cont, menționați contul din înregistrarea din depozit sau setați contul de inventar implicit din compania {1}.",
-Warehouses with child nodes cannot be converted to ledger,Depozitele cu noduri copil nu pot fi convertite în registru contabil,
-Warehouses with existing transaction can not be converted to group.,Depozite tranzacție existente nu pot fi convertite în grup.,
-Warehouses with existing transaction can not be converted to ledger.,Depozitele cu tranzacții existente nu pot fi convertite în registru contabil.,
-Warning,Avertisment,
-Warning: Another {0} # {1} exists against stock entry {2},Atenție: Un alt {0} # {1} există împotriva intrării stoc {2},
-Warning: Invalid SSL certificate on attachment {0},Atenție: certificat SSL invalid pe atașament {0},
-Warning: Invalid attachment {0},Atenție: Attachment invalid {0},
-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 Customer's Purchase Order {1},Atenție: comandă de vânzări {0} există deja împotriva Ordinului de Procurare clientului {1},
-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,garanţie,
-Warranty Claim,Garanție revendicarea,
-Warranty Claim against Serial No.,Garantie revendicarea împotriva Serial No.,
-Website,Site web,
-Website Image should be a public file or website URL,Site-ul Image ar trebui să fie un fișier public sau site-ul URL-ul,
-Website Image {0} attached to Item {1} cannot be found,Site-ul Image {0} atașat la postul {1} nu poate fi găsit,
-Website Listing,Înregistrarea site-ului,
-Website Manager,Site-ul Manager de,
-Website Settings,Setarile site-ului,
-Wednesday,Miercuri,
-Week,Săptămână,
-Weekdays,Zilele saptamanii,
-Weekly,Săptămânal,
-"Weight is mentioned,\nPlease mention ""Weight UOM"" too",,
-Welcome email sent,E-mailul de bun venit a fost trimis,
-Welcome to ERPNext,Bine ati venit la ERPNext,
-What do you need help with?,La ce ai nevoie de ajutor?,
-What does it do?,Ce face?,
-Where manufacturing operations are carried.,În cazul în care operațiunile de fabricație sunt efectuate.,
-White,alb,
-Wire Transfer,Transfer,
-WooCommerce Products,Produse WooCommerce,
-Work In Progress,Lucrări în curs,
-Work Order,Comandă de lucru,
-Work Order already created for all items with BOM,Ordin de lucru deja creat pentru toate articolele cu BOM,
-Work Order cannot be raised against a Item Template,Ordinul de lucru nu poate fi ridicat împotriva unui șablon de element,
-Work Order has been {0},Ordinul de lucru a fost {0},
-Work Order not created,Ordinul de lucru nu a fost creat,
-Work Order {0} must be cancelled before cancelling this Sales Order,Ordinul de lucru {0} trebuie anulat înainte de a anula acest ordin de vânzări,
-Work Order {0} must be submitted,Ordinul de lucru {0} trebuie trimis,
-Work Orders Created: {0},Comenzi de lucru create: {0},
-Work Summary for {0},Rezumat Lucrare pentru {0},
-Work-in-Progress Warehouse is required before Submit,De lucru-in-Progress Warehouse este necesară înainte Trimite,
-Workflow,Flux de lucru,
-Working,De lucru,
-Working Hours,Ore de lucru,
-Workstation,Stație de lucru,
-Workstation is closed on the following dates as per Holiday List: {0},Workstation este închis la următoarele date ca pe lista de vacanta: {0},
-Wrapping up,Înfășurați-vă,
-Wrong Password,Parola gresita,
-Year start date or end date is overlapping with {0}. To avoid please set company,Anul Data de începere sau de încheiere este suprapunerea cu {0}. Pentru a evita vă rugăm să setați companie,
-You are not authorized to add or update entries before {0},Nu ești autorizat să adăugi sau să actualizezi intrări înainte de {0},
-You are not authorized to approve leaves on Block Dates,Tu nu sunt autorizate să aprobe frunze pe bloc Perioada,
-You are not authorized to set Frozen value,Nu esti autorizat pentru a configura valoarea Congelat,
-You are not present all day(s) between compensatory leave request days,Nu vă prezentați toată ziua (zilele) între zilele de solicitare a plății compensatorii,
-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 current voucher in 'Against Journal Entry' column,"Nu puteți introduce voucher curent în ""Împotriva Jurnalul intrare"" coloană",
-You can only have Plans with the same billing cycle in a Subscription,Puteți avea numai planuri cu același ciclu de facturare într-un abonament,
-You can only redeem max {0} points in this order.,Puteți răscumpăra maxim {0} puncte în această ordine.,
-You can only renew if your membership expires within 30 days,Puteți reînnoi numai dacă expirați în termen de 30 de zile,
-You can only select a maximum of one option from the list of check boxes.,Puteți selecta numai o singură opțiune din lista de casete de selectare.,
-You can only submit Leave Encashment for a valid encashment amount,Puteți să trimiteți numai permisiunea de înregistrare pentru o sumă validă de încasare,
-You can't redeem Loyalty Points having more value than the Grand Total.,Nu puteți valorifica punctele de loialitate cu valoare mai mare decât suma totală.,
-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 cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Nu puteți șterge Anul fiscal {0}. Anul fiscal {0} este setat ca implicit în Setări globale,
-You cannot delete Project Type 'External',Nu puteți șterge tipul de proiect &quot;extern&quot;,
-You cannot edit root node.,Nu puteți edita nodul rădăcină.,
-You cannot restart a Subscription that is not cancelled.,Nu puteți reporni o abonament care nu este anulat.,
-You don't have enought Loyalty Points to redeem,Nu aveți puncte de loialitate pentru a răscumpăra,
-You have already assessed for the assessment criteria {}.,Ați evaluat deja criteriile de evaluare {}.,
-You have already selected items from {0} {1},Ați selectat deja un produs de la {0} {1},
-You have been invited to collaborate on the project: {0},Ați fost invitat să colaboreze la proiect: {0},
-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 need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,Trebuie să fii alt utilizator decât Administrator cu rolul managerului de sistem și al Managerului de articole pentru a te înregistra pe Marketplace.,
-You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,Trebuie să fii un utilizator cu roluri de manager de sistem și manager de articole pentru a adăuga utilizatori la Marketplace.,
-You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Trebuie să fiți utilizator cu funcții Manager Manager și Manager de posturi pentru a vă înregistra pe Marketplace.,
-You need to be logged in to access this page,Trebuie să fii conectat pentru a putea accesa această pagină,
-You need to enable Shopping Cart,Trebuie să activați Coșul de cumpărături,
-You will lose records of previously generated invoices. Are you sure you want to restart this subscription?,Veți pierde înregistrări ale facturilor generate anterior. Sigur doriți să reporniți acest abonament?,
-Your Organization,Organizația dumneavoastră,
-Your cart is Empty,Coșul dvs. este gol,
-Your email address...,Adresa ta de email...,
-Your order is out for delivery!,Comanda dvs. este livrată!,
-Your tickets,Biletele tale,
-ZIP Code,Cod postal,
-[Error],[Eroare],
-[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Forma / Postul / {0}) este din stoc,
-`Freeze Stocks Older Than` should be smaller than %d days.,'Blochează stocuri mai vechi decât' ar trebui să fie mai mic de %d zile.,
-based_on,bazat pe,
-cannot be greater than 100,nu poate fi mai mare de 100,
-disabled user,utilizator dezactivat,
-"e.g. ""Build tools for builders""","de exemplu ""Construi instrumente de constructori """,
-"e.g. ""Primary School"" or ""University""","de exemplu, &quot;Școala primară&quot; sau &quot;Universitatea&quot;",
-"e.g. Bank, Cash, Credit Card","de exemplu, bancar, Cash, Card de credit",
-hidden,ascuns,
-modified,modificată,
-old_parent,old_parent,
-on,Pornit,
-{0} '{1}' is disabled,{0} '{1}' este dezactivat,
-{0} '{1}' not in Fiscal Year {2},{0} '{1}' nu există în anul fiscal {2},
-{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) nu poate fi mai mare decât cantitatea planificată ({2}) din Ordinul de Lucru {3},
-{0} - {1} is inactive student,{0} - {1} este elev inactiv,
-{0} - {1} is not enrolled in the Batch {2},{0} - {1} nu este înscris în lotul {2},
-{0} - {1} is not enrolled in the Course {2},{0} - {1} nu este înscris la Cursul {2},
-{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},Bugetul {0} pentru Contul {1} față de {2} {3} este {4}. Acesta este depășit cu {5},
-{0} Digest,{0} Digest,
-{0} Request for {1},{0} Cerere pentru {1},
-{0} Result submittted,{0} Rezultat transmis,
-{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} numere de serie necesare pentru postul {1}. Ați furnizat {2}.,
-{0} Student Groups created.,{0} Grupurile de elevi au fost create.,
-{0} Students have been enrolled,{0} Elevii au fost înscriși,
-{0} against Bill {1} dated {2},{0} comparativ cu factura {1} din data de {2},
-{0} against Purchase Order {1},{0} comparativ cu comanda de cumpărare {1},
-{0} against Sales Invoice {1},{0} comparativ cu factura de vânzări {1},
-{0} against Sales Order {1},{0} comparativ cu comanda de vânzări {1},
-{0} already allocated for Employee {1} for period {2} to {3},{0} deja alocate pentru Angajatul {1} pentru perioada {2} - {3},
-{0} applicable after {1} working days,{0} aplicabil după {1} zile lucrătoare,
-{0} asset cannot be transferred,{0} activul nu poate fi transferat,
-{0} can not be negative,{0} nu poate fi negativ,
-{0} created,{0} creat,
-"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.","{0} are în prezent {1} Scor de Furnizor, iar comenzile de achiziție catre acest furnizor ar trebui emise cu prudență.",
-"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.","{0} are în prezent {1} Scor de Furnizor, iar cererile de oferta către acest furnizor ar trebui emise cu prudență.",
-{0} does not belong to Company {1},{0} nu aparține Companiei {1},
-{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0} nu are un program de practicieni în domeniul sănătății. Adăugați-o la medicul de masterat în domeniul sănătății,
-{0} entered twice in Item Tax,{0} a fost introdus de două ori în taxa articolului,
-{0} for {1},{0} pentru {1},
-{0} has been submitted successfully,{0} a fost trimis cu succes,
-{0} has fee validity till {1},{0} are valabilitate până la data de {1},
-{0} hours,{0} ore,
-{0} in row {1},{0} în rândul {1},
-{0} is blocked so this transaction cannot proceed,"{0} este blocat, astfel încât această tranzacție nu poate continua",
-{0} is mandatory,{0} este obligatoriu,
-{0} is mandatory for Item {1},{0} este obligatoriu pentru articolul {1},
-{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} este obligatoriu. Este posibil ca înregistrarea schimbului valutar nu este creată pentru {1} până la {2}.,
-{0} is not a stock Item,{0} nu este un articol de stoc,
-{0} is not a valid Batch Number for Item {1},{0} nu este un număr de lot valid aferent articolului {1},
-{0} is not added in the table,{0} nu este adăugat în tabel,
-{0} is not in Optional Holiday List,{0} nu este în lista de sărbători opționale,
-{0} is not in a valid Payroll Period,{0} nu este într-o Perioadă de Salarizare validă,
-{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} este acum anul fiscal implicit. Vă rugăm să reîmprospătați browser-ul dvs. pentru ca modificarea să aibă efect.,
-{0} is on hold till {1},{0} este în așteptare până la {1},
-{0} item found.,{0} element găsit.,
-{0} items found.,{0} articole găsite.,
-{0} items in progress,{0} elemente în curs,
-{0} items produced,{0} articole produse,
-{0} must appear only once,{0} trebuie să apară doar o singură dată,
-{0} must be negative in return document,{0} trebuie să fie negativ în documentul de retur,
-{0} must be submitted,{0} trebuie transmis,
-{0} not allowed to transact with {1}. Please change the Company.,{0} nu este permis să efectueze tranzacții cu {1}. Vă rugăm să schimbați compania selectată.,
-{0} not found for item {1},{0} nu a fost găsit pentru articolul {1},
-{0} parameter is invalid,Parametrul {0} este nevalid,
-{0} payment entries can not be filtered by {1},{0} înregistrări de plată nu pot fi filtrate de {1},
-{0} should be a value between 0 and 100,{0} ar trebui să fie o valoare cuprinsă între 0 și 100,
-{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} unități de [{1}] (# Forma / Postul / {1}) găsit în [{2}] (# Forma / Depozit / {2}),
-{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} unități de {1} necesare în {2} pe {3} {4} pentru {5} pentru a finaliza această tranzacție.,
-{0} units of {1} needed in {2} to complete this transaction.,{0} unități de {1} necesare în {2} pentru a finaliza această tranzacție.,
-{0} valid serial nos for Item {1},{0} numere de serie valabile pentru articolul {1},
-{0} variants created.,{0} variante create.,
-{0} {1} created,{0} {1} creat,
-{0} {1} does not exist,{0} {1} nu există,
-{0} {1} has been modified. Please refresh.,{0} {1} a fost modificat. Vă rugăm să reîmprospătați.,
-{0} {1} has not been submitted so the action cannot be completed,"{0} {1} nu a fost transmis, astfel încât acțiunea nu poate fi finalizată",
-"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} este asociat cu {2}, dar contul de partid este {3}",
-{0} {1} is cancelled or closed,{0} {1} este anulat sau închis,
-{0} {1} is cancelled or stopped,{0} {1} este anulată sau oprită,
-{0} {1} is cancelled so the action cannot be completed,"{0} {1} este anulată, astfel încât acțiunea nu poate fi terminată",
-{0} {1} is closed,{0} {1} este închis,
-{0} {1} is disabled,{0} {1} este dezactivat,
-{0} {1} is frozen,{0} {1} este blocat,
-{0} {1} is fully billed,{0} {1} este complet facturat,
-{0} {1} is not active,{0} {1} nu este activ,
-{0} {1} is not associated with {2} {3},{0} {1} nu este asociat cu {2} {3},
-{0} {1} is not present in the parent company,{0} {1} nu este prezentă în compania mamă,
-{0} {1} is not submitted,{0} {1} nu este introdus,
-{0} {1} is {2},{0} {1} este {2},
-{0} {1} must be submitted,{0} {1} trebuie să fie introdus,
-{0} {1} not in any active Fiscal Year.,{0} {1} nu se gaseste in niciun an fiscal activ.,
-{0} {1} status is {2},{0} {1} statusul este {2},
-{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: &quot;profit și pierdere&quot; cont de tip {2} nu este permisă în orificiul de intrare,
-{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Cont {2} nu aparține Companiei {3},
-{0} {1}: Account {2} is inactive,{0} {1}: Cont {2} este inactiv,
-{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Intrarea contabila {2} poate fi făcută numai în moneda: {3},
-{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: 아이템 {2} 는 Cost Center가  필수임,
-{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,{0} {1}: Centru de cost este necesară pentru &quot;profit și pierdere&quot; cont de {2}. Vă rugăm să configurați un centru de cost implicit pentru companie.,
-{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Cost Center {2} nu aparține Companiei {3},
-{0} {1}: Customer is required against Receivable account {2},{0} {1}: Clientul este necesară împotriva contului Receivable {2},
-{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Fie valoarea creditului de debit sau creditul sunt necesare pentru {2},
-{0} {1}: Supplier is required against Payable account {2},{0} {1}: Furnizorul este necesar pentru Contul de plăți {2},
-{0}% Billed,{0}% facturat,
-{0}% Delivered,{0}% livrat,
-"{0}: Employee email not found, hence email not sent","{0}: E-mail-ul angajatului nu a fost găsit, prin urmare, nu a fost trimis mail",
-{0}: From {0} of type {1},{0}: de la {0} de tipul {1},
-{0}: From {1},{0}: De la {1},
-{0}: {1} does not exists,{0}: {1} nu există,
-{0}: {1} not found in Invoice Details table,{0}: {1} nu a fost găsit în tabelul Detalii factură,
-{} of {},{} de {},
-Assigned To,Atribuit pentru,
-Chat,Chat,
-Completed By,Completat De,
-Conditions,Condiții,
-County,județ,
-Day of Week,Zi a săptămânii,
-"Dear System Manager,","Dragă System Manager,",
-Default Value,Valoare implicită,
-Email Group,E-mail grup,
-Email Settings,Setări e-mail,
-Email not sent to {0} (unsubscribed / disabled),Nu e-mail trimis la {0} (nesubscrise / dezactivat),
-Error Message,Mesaj de eroare,
-Fieldtype,Tip câmp,
-Help Articles,Articole de ajutor,
-ID,ID-ul,
-Images,Imagini,
-Import,Importarea,
-Language,Limba,
-Likes,Au apreciat,
-Merge with existing,Merge cu existente,
-Office,Birou,
-Orientation,Orientare,
-Parent,Mamă,
-Passive,Pasiv,
-Payment Failed,Plata esuata,
-Percent,La sută,
-Permanent,Permanent,
-Personal,Trader,
-Plant,Instalarea,
-Post,Publică,
-Postal,Poștal,
-Postal Code,Cod poștal,
-Previous,Precedenta,
-Provider,Furnizor de,
-Read Only,Doar Citire,
-Recipient,Destinatar,
-Reviews,opinii,
-Sender,Expeditor,
-Shop,Magazin,
-Subsidiary,Filială,
-There is some problem with the file url: {0},Există unele probleme cu URL-ul fișierului: {0},
-There were errors while sending email. Please try again.,Au fost erori în timp ce trimiterea de e-mail. Încercaţi din nou.,
-Values Changed,valori schimbată,
-or,sau,
-Ageing Range 4,Intervalul de îmbătrânire 4,
-Allocated amount cannot be greater than unadjusted amount,Suma alocată nu poate fi mai mare decât suma nejustificată,
-Allocated amount cannot be negative,Suma alocată nu poate fi negativă,
-"Difference Account must be a Asset/Liability type account, since this Stock Entry is an Opening Entry","Contul de diferență trebuie să fie un cont de tip Active / Răspundere, deoarece această intrare de stoc este o intrare de deschidere",
-Error in some rows,Eroare în unele rânduri,
-Import Successful,Import de succes,
-Please save first,Vă rugăm să salvați mai întâi,
-Price not found for item {0} in price list {1},Preț care nu a fost găsit pentru articolul {0} din lista de prețuri {1},
-Warehouse Type,Tip depozit,
-'Date' is required,„Data” este necesară,
-Benefit,Beneficiu,
-Budgets,Bugete,
-Bundle Qty,Cantitate de pachet,
-Company GSTIN,Compania GSTIN,
-Company field is required,Câmpul companiei este obligatoriu,
-Creating Dimensions...,Crearea dimensiunilor ...,
-Duplicate entry against the item code {0} and manufacturer {1},Duplică intrarea în codul articolului {0} și producătorul {1},
-Invalid GSTIN! The input you've entered doesn't match the GSTIN format for UIN Holders or Non-Resident OIDAR Service Providers,GSTIN nevalid! Intrarea introdusă nu se potrivește cu formatul GSTIN pentru deținătorii de UIN sau furnizorii de servicii OIDAR nerezidenți,
-Invoice Grand Total,Total factură mare,
-Last carbon check date cannot be a future date,Ultima dată de verificare a carbonului nu poate fi o dată viitoare,
-Make Stock Entry,Faceți intrarea în stoc,
-Quality Feedback,Feedback de calitate,
-Quality Feedback Template,Șablon de feedback de calitate,
-Rules for applying different promotional schemes.,Reguli pentru aplicarea diferitelor scheme promoționale.,
-Shift,Schimb,
-Show {0},Afișați {0},
-"Special Characters except '-', '#', '.', '/', '{{' and '}}' not allowed in naming series {0}","Caractere speciale, cu excepția &quot;-&quot;, &quot;#&quot;, &quot;.&quot;, &quot;/&quot;, &quot;{{&quot; Și &quot;}}&quot; nu sunt permise în numirea seriei {0}",
-Target Details,Detalii despre țintă,
-{0} already has a Parent Procedure {1}.,{0} are deja o procedură părinte {1}.,
-API,API-ul,
-Annual,Anual,
-Approved,Aprobat,
-Change,Schimbă,
-Contact Email,Email Persoana de Contact,
-Export Type,Tipul de export,
-From Date,Din data,
-Group By,A se grupa cu,
-Importing {0} of {1},Importarea {0} din {1},
-Invalid URL,URL invalid,
-Landscape,Peisaj,
-Last Sync On,Ultima sincronizare activată,
-Naming Series,Naming Series,
-No data to export,Nu există date de exportat,
-Portrait,Portret,
-Print Heading,Imprimare Titlu,
-Scheduler Inactive,Planificator inactiv,
-Scheduler is inactive. Cannot import data.,Planificatorul este inactiv. Nu se pot importa date.,
-Show Document,Afișează documentul,
-Show Traceback,Afișare Traceback,
-Video,Video,
-Webhook Secret,Secret Webhook,
-% Of Grand Total,% Din totalul mare,
-'employee_field_value' and 'timestamp' are required.,„angajat_field_value” și „timestamp” sunt obligatorii.,
-<b>Company</b> is a mandatory filter.,<b>Compania</b> este un filtru obligatoriu.,
-<b>From Date</b> is a mandatory filter.,<b>De la Date</b> este un filtru obligatoriu.,
-<b>From Time</b> cannot be later than <b>To Time</b> for {0},<b>From Time</b> nu poate fi mai târziu decât <b>To Time</b> pentru {0},
-<b>To Date</b> is a mandatory filter.,<b>Până în prezent</b> este un filtru obligatoriu.,
-A new appointment has been created for you with {0},O nouă programare a fost creată pentru dvs. cu {0},
-Account Value,Valoarea contului,
-Account is mandatory to get payment entries,Contul este obligatoriu pentru a obține înregistrări de plată,
-Account is not set for the dashboard chart {0},Contul nu este setat pentru graficul de bord {0},
-Account {0} does not belong to company {1},Contul {0} nu aparține companiei {1},
-Account {0} does not exists in the dashboard chart {1},Contul {0} nu există în graficul de bord {1},
-Account: <b>{0}</b> is capital Work in progress and can not be updated by Journal Entry,Cont: <b>{0}</b> este capital de lucru în desfășurare și nu poate fi actualizat de jurnalul de intrare,
-Account: {0} is not permitted under Payment Entry,Cont: {0} nu este permis în baza intrării de plată,
-Accounting Dimension <b>{0}</b> is required for 'Balance Sheet' account {1}.,Dimensiunea contabilității <b>{0}</b> este necesară pentru contul „bilanț” {1}.,
-Accounting Dimension <b>{0}</b> is required for 'Profit and Loss' account {1}.,Dimensiunea contabilității <b>{0}</b> este necesară pentru contul „Profit și pierdere” {1}.,
-Accounting Masters,Maeștri contabili,
-Accounting Period overlaps with {0},Perioada de contabilitate se suprapune cu {0},
-Activity,Activitate,
-Add / Manage Email Accounts.,Adăugați / gestionați conturi de e-mail.,
-Add Child,Adăugă Copil,
-Add Loan Security,Adăugați securitatea împrumutului,
-Add Multiple,Adăugați mai multe,
-Add Participants,Adăugă Participanți,
-Add to Featured Item,Adăugați la elementele prezentate,
-Add your review,Adăugați-vă recenzia,
-Add/Edit Coupon Conditions,Adăugați / Editați Condițiile cuponului,
-Added to Featured Items,Adăugat la Elementele prezentate,
-Added {0} ({1}),Adăugat {0} ({1}),
-Address Line 1,Adresă Linie 1,
-Addresses,Adrese,
-Admission End Date should be greater than Admission Start Date.,Data de încheiere a admisiei ar trebui să fie mai mare decât data de începere a admiterii.,
-Against Loan,Contra împrumutului,
-Against Loan:,Împrumut contra,
-All,Toate,
-All bank transactions have been created,Toate tranzacțiile bancare au fost create,
-All the depreciations has been booked,Toate amortizările au fost înregistrate,
-Allocation Expired!,Alocare expirată!,
-Allow Resetting Service Level Agreement from Support Settings.,Permiteți resetarea acordului de nivel de serviciu din setările de asistență,
-Amount of {0} is required for Loan closure,Suma de {0} este necesară pentru închiderea împrumutului,
-Amount paid cannot be zero,Suma plătită nu poate fi zero,
-Applied Coupon Code,Codul cuponului aplicat,
-Apply Coupon Code,Aplicați codul promoțional,
-Appointment Booking,Rezervare rezervare,
-"As there are existing transactions against item {0}, you can not change the value of {1}","Deoarece există tranzacții existente la postul {0}, nu puteți modifica valoarea {1}",
-Asset Id,ID material,
-Asset Value,Valoarea activului,
-Asset Value Adjustment cannot be posted before Asset's purchase date <b>{0}</b>.,Reglarea valorii activelor nu poate fi înregistrată înainte de data achiziției activelor <b>{0}</b> .,
-Asset {0} does not belongs to the custodian {1},Activul {0} nu aparține custodului {1},
-Asset {0} does not belongs to the location {1},Activele {0} nu aparțin locației {1},
-At least one of the Applicable Modules should be selected,Trebuie selectat cel puțin unul dintre modulele aplicabile,
-Atleast one asset has to be selected.,Cel puțin un activ trebuie să fie selectat.,
-Attendance Marked,Prezentare marcată,
-Attendance has been marked as per employee check-ins,Participarea a fost marcată conform check-in-urilor angajaților,
-Authentication Failed,Autentificare esuata,
-Automatic Reconciliation,Reconciliere automată,
-Available For Use Date,Disponibil pentru data de utilizare,
-Available Stock,Stoc disponibil,
-"Available quantity is {0}, you need {1}","Cantitatea disponibilă este {0}, aveți nevoie de {1}",
-BOM 1,BOM 1,
-BOM 2,BOM 2,
-BOM Comparison Tool,Instrument de comparare BOM,
-BOM recursion: {0} cannot be child of {1},Recurs recurs BOM: {0} nu poate fi copil de {1},
-BOM recursion: {0} cannot be parent or child of {1},Recurs din BOM: {0} nu poate fi părinte sau copil de {1},
-Back to Home,Înapoi acasă,
-Back to Messages,Înapoi la mesaje,
-Bank Data mapper doesn't exist,Mapper Data Bank nu există,
-Bank Details,Detalii bancare,
-Bank account '{0}' has been synchronized,Contul bancar „{0}” a fost sincronizat,
-Bank account {0} already exists and could not be created again,Contul bancar {0} există deja și nu a mai putut fi creat din nou,
-Bank accounts added,S-au adăugat conturi bancare,
-Batch no is required for batched item {0},Numărul lot nu este necesar pentru articol lot {0},
-Billing Date,Data de facturare,
-Billing Interval Count cannot be less than 1,Numărul de intervale de facturare nu poate fi mai mic de 1,
-Blue,Albastru,
-Book,Carte,
-Book Appointment,Numire carte,
-Brand,Marca,
-Browse,Parcurgere,
-Call Connected,Apel conectat,
-Call Disconnected,Apel deconectat,
-Call Missed,Sună dor,
-Call Summary,Rezumatul apelului,
-Call Summary Saved,Rezumat apel salvat,
-Cancelled,Anulat,
-Cannot Calculate Arrival Time as Driver Address is Missing.,Nu se poate calcula ora de sosire deoarece adresa șoferului lipsește.,
-Cannot Optimize Route as Driver Address is Missing.,Nu se poate optimiza ruta deoarece adresa șoferului lipsește.,
-Cannot complete task {0} as its dependant task {1} are not ccompleted / cancelled.,Nu se poate finaliza sarcina {0} ca sarcină dependentă {1} nu sunt completate / anulate.,
-Cannot create loan until application is approved,Nu se poate crea împrumut până la aprobarea cererii,
-Cannot find a matching Item. Please select some other value for {0}.,Nu pot găsi o potrivire articol. Vă rugăm să selectați o altă valoare pentru {0}.,
-"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Nu se poate depăși pentru articolul {0} din rândul {1} mai mult decât {2}. Pentru a permite supra-facturarea, vă rugăm să setați alocația în Setările conturilor",
-"Capacity Planning Error, planned start time can not be same as end time","Eroare de planificare a capacității, ora de pornire planificată nu poate fi aceeași cu ora finală",
-Categories,Categorii,
-Changes in {0},Modificări în {0},
-Chart,Diagramă,
-Choose a corresponding payment,Alegeți o plată corespunzătoare,
-Click on the link below to verify your email and confirm the appointment,Faceți clic pe linkul de mai jos pentru a vă confirma e-mailul și pentru a confirma programarea,
-Close,Închideți,
-Communication,Comunicare,
-Compact Item Print,Compact Postul de imprimare,
-Company,Compania,
-Company of asset {0} and purchase document {1} doesn't matches.,Compania de activ {0} și documentul de achiziție {1} nu se potrivesc.,
-Compare BOMs for changes in Raw Materials and Operations,Comparați OM-urile pentru modificările materiilor prime și operațiunilor,
-Compare List function takes on list arguments,Comparați funcția Listă ia argumentele listei,
-Complete,Complet,
-Completed,Finalizat,
-Completed Quantity,Cantitate completată,
-Connect your Exotel Account to ERPNext and track call logs,Conectați contul dvs. Exotel la ERPNext și urmăriți jurnalele de apeluri,
-Connect your bank accounts to ERPNext,Conectați-vă conturile bancare la ERPNext,
-Contact Seller,Contacteaza vanzatorul,
-Continue,Continua,
-Cost Center: {0} does not exist,Centrul de costuri: {0} nu există,
-Couldn't Set Service Level Agreement {0}.,Nu s-a putut stabili acordul de nivel de serviciu {0}.,
-Country,Ţară,
-Country Code in File does not match with country code set up in the system,Codul de țară din fișier nu se potrivește cu codul de țară configurat în sistem,
-Create New Contact,Creați un nou contact,
-Create New Lead,Creați noul plumb,
-Create Pick List,Creați lista de alegeri,
-Create Quality Inspection for Item {0},Creați inspecție de calitate pentru articol {0},
-Creating Accounts...,Crearea de conturi ...,
-Creating bank entries...,Crearea intrărilor bancare ...,
-Credit limit is already defined for the Company {0},Limita de credit este deja definită pentru companie {0},
-Ctrl + Enter to submit,Ctrl + Enter pentru a trimite,
-Ctrl+Enter to submit,Ctrl + Enter pentru a trimite,
-Currency,Valută,
-Current Status,Starea curentă a armatei,
-Customer PO,PO de client,
-Customize,Personalizeaza,
-Daily,Zilnic,
-Date,Dată,
-Date Range,Interval de date,
-Date of Birth cannot be greater than Joining Date.,Data nașterii nu poate fi mai mare decât data de aderare.,
-Dear,Dragă,
-Default,Implicit,
-Define coupon codes.,Definiți codurile cuponului.,
-Delayed Days,Zile amânate,
-Delete,Șterge,
-Delivered Quantity,Cantitate livrată,
-Delivery Notes,Note de livrare,
-Depreciated Amount,Suma depreciată,
-Description,Descriere,
-Designation,Destinatie,
-Difference Value,Valoarea diferenței,
-Dimension Filter,Filtrul de dimensiuni,
-Disabled,Dezactivat,
-Disbursement and Repayment,Plată și rambursare,
-Distance cannot be greater than 4000 kms,Distanța nu poate fi mai mare de 4000 km,
-Do you want to submit the material request,Doriți să trimiteți solicitarea materialului,
-Doctype,doctype,
-Document {0} successfully uncleared,Documentul {0} nu a fost clar necunoscut,
-Download Template,Descărcați Sablon,
-Dr,Dr,
-Due Date,Data Limita,
-Duplicate,Duplicat,
-Duplicate Project with Tasks,Duplică proiect cu sarcini,
-Duplicate project has been created,Proiectul duplicat a fost creat,
-E-Way Bill JSON can only be generated from a submitted document,e-Way Bill JSON poate fi generat numai dintr-un document trimis,
-E-Way Bill JSON can only be generated from submitted document,E-Way Bill JSON poate fi generat numai din documentul trimis,
-E-Way Bill JSON cannot be generated for Sales Return as of now,E-Way Bill JSON nu poate fi generat pentru Returnarea vânzărilor de acum,
-ERPNext could not find any matching payment entry,ERPNext nu a găsit nicio intrare de plată potrivită,
-Earliest Age,Cea mai timpurie vârstă,
-Edit Details,Editează detaliile,
-Edit Profile,Editează profilul,
-Either GST Transporter ID or Vehicle No is required if Mode of Transport is Road,"Fie ID-ul transportatorului GST, fie numărul vehiculului nu este necesar dacă modul de transport este rutier",
-Email,E-mail,
-Email Campaigns,Campanii prin e-mail,
-Employee ID is linked with another instructor,ID-ul angajaților este legat de un alt instructor,
-Employee Tax and Benefits,Impozitul și beneficiile angajaților,
-Employee is required while issuing Asset {0},Angajatul este necesar la emiterea de activ {0},
-Employee {0} does not belongs to the company {1},Angajatul {0} nu aparține companiei {1},
-Enable Auto Re-Order,Activați re-comanda automată,
-End Date of Agreement can't be less than today.,Data de încheiere a acordului nu poate fi mai mică decât astăzi.,
-End Time,End Time,
-Energy Point Leaderboard,Tabloul de bord al punctelor energetice,
-Enter API key in Google Settings.,Introduceți cheia API în Setări Google.,
-Enter Supplier,Introduceți furnizorul,
-Enter Value,Introduceți valoarea,
-Entity Type,Tip de entitate,
-Error,Eroare,
-Error in Exotel incoming call,Eroare în apelul primit la Exotel,
-Error: {0} is mandatory field,Eroare: {0} este câmp obligatoriu,
-Event Link,Link de eveniment,
-Exception occurred while reconciling {0},Excepție a avut loc în timp ce s-a reconciliat {0},
-Expected and Discharge dates cannot be less than Admission Schedule date,Datele preconizate și descărcarea de gestiune nu pot fi mai mici decât Data planificării de admitere,
-Expire Allocation,Expirați alocarea,
-Expired,Expirat,
-Export,Exportă,
-Export not allowed. You need {0} role to export.,Export nu este permisă. Ai nevoie de {0} rolul de a exporta.,
-Failed to add Domain,Nu a putut adăuga Domeniul,
-Fetch Items from Warehouse,Obține obiecte de la Depozit,
-Fetching...,... Fetching,
-Field,Camp,
-File Manager,Manager de fișiere,
-Filters,Filtre,
-Finding linked payments,Găsirea plăților legate,
-Fleet Management,Conducerea flotei,
-Following fields are mandatory to create address:,Următoarele câmpuri sunt obligatorii pentru a crea adresa:,
-For Month,Pentru luna,
-"For item {0} at row {1}, count of serial numbers does not match with the picked quantity","Pentru articolul {0} din rândul {1}, numărul de serii nu se potrivește cu cantitatea aleasă",
-For operation {0}: Quantity ({1}) can not be greter than pending quantity({2}),Pentru operare {0}: cantitatea ({1}) nu poate fi mai mare decât cantitatea în curs ({2}),
-For quantity {0} should not be greater than work order quantity {1},Pentru cantitatea {0} nu trebuie să fie mai mare decât cantitatea de comandă de lucru {1},
-Free item not set in the pricing rule {0},Element gratuit care nu este setat în regula prețurilor {0},
-From Date and To Date are Mandatory,De la data și până la data sunt obligatorii,
-From employee is required while receiving Asset {0} to a target location,De la angajat este necesar în timp ce primiți Active {0} către o locație țintă,
-Fuel Expense,Cheltuieli de combustibil,
-Future Payment Amount,Suma viitoare de plată,
-Future Payment Ref,Plată viitoare Ref,
-Future Payments,Plăți viitoare,
-GST HSN Code does not exist for one or more items,Codul GST HSN nu există pentru unul sau mai multe articole,
-Generate E-Way Bill JSON,Generați JSON Bill e-Way,
-Get Items,Obtine Articole,
-Get Outstanding Documents,Obțineți documente de excepție,
-Goal,Obiectiv,
-Greater Than Amount,Mai mare decât suma,
-Green,Verde,
-Group,Grup,
-Group By Customer,Grup după client,
-Group By Supplier,Grup după furnizor,
-Group Node,Nod Group,
-Group Warehouses cannot be used in transactions. Please change the value of {0},Depozitele de grup nu pot fi utilizate în tranzacții. Vă rugăm să schimbați valoarea {0},
-Help,Ajutor,
-Help Article,articol de ajutor,
-"Helps you keep tracks of Contracts based on Supplier, Customer and Employee","Te ajută să ții evidența contractelor bazate pe furnizor, client și angajat",
-Helps you manage appointments with your leads,Vă ajută să gestionați programările cu clienții dvs.,
-Home,Acasă,
-IBAN is not valid,IBAN nu este valid,
-Import Data from CSV / Excel files.,Importați date din fișiere CSV / Excel.,
-In Progress,In progres,
-Incoming call from {0},Apel primit de la {0},
-Incorrect Warehouse,Depozit incorect,
-Intermediate,Intermediar,
-Invalid Barcode. There is no Item attached to this barcode.,Cod de bare nevalid. Nu există niciun articol atașat acestui cod de bare.,
-Invalid credentials,Credențe nevalide,
-Invite as User,Invitați ca utilizator,
-Issue Priority.,Prioritate de emisiune.,
-Issue Type.,Tipul problemei.,
-"It seems that there is an issue with the server's stripe configuration. In case of failure, the amount will get refunded to your account.","Se pare că există o problemă cu configurația benzii serverului. În caz de eșec, suma va fi rambursată în cont.",
-Item Reported,Articol raportat,
-Item listing removed,Elementul de articol a fost eliminat,
-Item quantity can not be zero,Cantitatea articolului nu poate fi zero,
-Item taxes updated,Impozitele pe articol au fost actualizate,
-Item {0}: {1} qty produced. ,Articol {0}: {1} cantitate produsă.,
-Joining Date can not be greater than Leaving Date,Data de înscriere nu poate fi mai mare decât Data de plecare,
-Lab Test Item {0} already exist,Elementul testului de laborator {0} există deja,
-Last Issue,Ultima problemă,
-Latest Age,Etapă tarzie,
-Leave application is linked with leave allocations {0}. Leave application cannot be set as leave without pay,Cererea de concediu este legată de alocațiile de concediu {0}. Cererea de concediu nu poate fi stabilită ca concediu fără plată,
-Leaves Taken,Frunze luate,
-Less Than Amount,Mai puțin decât suma,
-Liabilities,pasive,
-Loading...,Se încarcă...,
-Loan Amount exceeds maximum loan amount of {0} as per proposed securities,Suma împrumutului depășește valoarea maximă a împrumutului de {0} conform valorilor mobiliare propuse,
-Loan Applications from customers and employees.,Aplicații de împrumut de la clienți și angajați.,
-Loan Disbursement,Decontarea împrumutului,
-Loan Processes,Procese de împrumut,
-Loan Security,Securitatea împrumutului,
-Loan Security Pledge,Gaj de securitate pentru împrumuturi,
-Loan Security Pledge Created : {0},Creditul de securitate al împrumutului creat: {0},
-Loan Security Price,Prețul securității împrumutului,
-Loan Security Price overlapping with {0},Prețul securității împrumutului care se suprapune cu {0},
-Loan Security Unpledge,Unplingge de securitate a împrumutului,
-Loan Security Value,Valoarea securității împrumutului,
-Loan Type for interest and penalty rates,Tip de împrumut pentru dobânzi și rate de penalizare,
-Loan amount cannot be greater than {0},Valoarea împrumutului nu poate fi mai mare de {0},
-Loan is mandatory,Împrumutul este obligatoriu,
-Loans,Credite,
-Loans provided to customers and employees.,Împrumuturi acordate clienților și angajaților.,
-Location,Închiriere,
-Log Type is required for check-ins falling in the shift: {0}.,Tipul de jurnal este necesar pentru check-in-urile care intră în schimb: {0}.,
-Looks like someone sent you to an incomplete URL. Please ask them to look into it.,Se pare că cineva te-a trimis la o adresă URL incompletă. Vă rugăm să cereți-le să se uite în ea.,
-Make Journal Entry,Asigurați Jurnal intrare,
-Make Purchase Invoice,Realizeaza Factura de Cumparare,
-Manufactured,Fabricat,
-Mark Work From Home,Marcați munca de acasă,
-Master,Master,
-Max strength cannot be less than zero.,Rezistența maximă nu poate fi mai mică de zero.,
-Maximum attempts for this quiz reached!,Încercări maxime pentru acest test au fost atinse!,
-Message,Mesaj,
-Missing Values Required,Valorile lipsă necesare,
-Mobile No,Numar de mobil,
-Mobile Number,Numar de mobil,
-Month,Lună,
-Name,Nume,
-Near you,Lângă tine,
-Net Profit/Loss,Profit / Pierdere Netă,
-New Expense,Cheltuieli noi,
-New Invoice,Factură nouă,
-New Payment,Nouă plată,
-New release date should be in the future,Noua dată a lansării ar trebui să fie în viitor,
-Newsletter,Newsletter,
-No Account matched these filters: {},Niciun cont nu se potrivește cu aceste filtre: {},
-No Employee found for the given employee field value. '{}': {},Nu a fost găsit niciun angajat pentru valoarea câmpului dat. &#39;{}&#39;: {},
-No Leaves Allocated to Employee: {0} for Leave Type: {1},Fără frunze alocate angajaților: {0} pentru tipul de concediu: {1},
-No communication found.,Nu a fost găsită nicio comunicare.,
-No correct answer is set for {0},Nu este setat un răspuns corect pentru {0},
-No description,fără descriere,
-No issue has been raised by the caller.,Apelantul nu a pus nicio problemă.,
-No items to publish,Nu există articole de publicat,
-No outstanding invoices found,Nu s-au găsit facturi restante,
-No outstanding invoices found for the {0} {1} which qualify the filters you have specified.,Nu s-au găsit facturi restante pentru {0} {1} care califică filtrele pe care le-ați specificat.,
-No outstanding invoices require exchange rate revaluation,Fără facturi restante nu necesită reevaluarea cursului de schimb,
-No reviews yet,Niciun comentariu încă,
-No views yet,Nu există încă vizionări,
-Non stock items,Articole care nu sunt pe stoc,
-Not Allowed,Nu permise,
-Not allowed to create accounting dimension for {0},Nu este permisă crearea unei dimensiuni contabile pentru {0},
-Not permitted. Please disable the Lab Test Template,Nu sunt acceptate. Vă rugăm să dezactivați șablonul de testare,
-Note,Notă,
-Notes: ,Observații:,
-On Converting Opportunity,La convertirea oportunității,
-On Purchase Order Submission,La trimiterea comenzii de cumpărare,
-On Sales Order Submission,La trimiterea comenzii de vânzare,
-On Task Completion,La finalizarea sarcinii,
-On {0} Creation,La {0} Creație,
-Only .csv and .xlsx files are supported currently,"În prezent, numai fișierele .csv și .xlsx sunt acceptate",
-Only expired allocation can be cancelled,Numai alocarea expirată poate fi anulată,
-Only users with the {0} role can create backdated leave applications,Doar utilizatorii cu rolul {0} pot crea aplicații de concediu retardate,
-Open,Deschide,
-Open Contact,Deschideți contactul,
-Open Lead,Deschideți plumb,
-Opening and Closing,Deschiderea și închiderea,
-Operating Cost as per Work Order / BOM,Costul de operare conform ordinului de lucru / BOM,
-Order Amount,Cantitatea comenzii,
-Page {0} of {1},Pagină {0} din {1},
-Paid amount cannot be less than {0},Suma plătită nu poate fi mai mică de {0},
-Parent Company must be a group company,Compania-mamă trebuie să fie o companie de grup,
-Passing Score value should be between 0 and 100,Valoarea punctajului de trecere ar trebui să fie între 0 și 100,
-Password policy cannot contain spaces or simultaneous hyphens. The format will be restructured automatically,Politica de parolă nu poate conține spații sau cratime simultane. Formatul va fi restructurat automat,
-Patient History,Istoricul pacientului,
-Pause,Pauză,
-Pay,Plăti,
-Payment Document Type,Tip de document de plată,
-Payment Name,Numele de plată,
-Penalty Amount,Suma pedepsei,
-Pending,În așteptarea,
-Performance,Performanţă,
-Period based On,Perioada bazată pe,
-Perpetual inventory required for the company {0} to view this report.,Inventar perpetuu necesar companiei {0} pentru a vedea acest raport.,
-Phone,Telefon,
-Pick List,Lista de alegeri,
-Plaid authentication error,Eroare de autentificare plaidă,
-Plaid public token error,Eroare a simbolului public cu plaid,
-Plaid transactions sync error,Eroare de sincronizare a tranzacțiilor plasate,
-Please check the error log for details about the import errors,Verificați jurnalul de erori pentru detalii despre erorile de import,
-Please create <b>DATEV Settings</b> for Company <b>{}</b>.,Vă rugăm să creați <b>DATEV Setări</b> pentru companie <b>{}</b> .,
-Please create adjustment Journal Entry for amount {0} ,Vă rugăm să creați ajustarea Intrare în jurnal pentru suma {0},
-Please do not create more than 500 items at a time,Vă rugăm să nu creați mai mult de 500 de articole simultan,
-Please enter <b>Difference Account</b> or set default <b>Stock Adjustment Account</b> for company {0},Vă rugăm să introduceți <b>contul de diferență</b> sau să setați <b>contul de ajustare a stocului</b> implicit pentru compania {0},
-Please enter GSTIN and state for the Company Address {0},Vă rugăm să introduceți GSTIN și să indicați adresa companiei {0},
-Please enter Item Code to get item taxes,Vă rugăm să introduceți Codul articolului pentru a obține impozite pe articol,
-Please enter Warehouse and Date,Vă rugăm să introduceți Depozitul și data,
-Please enter the designation,Vă rugăm să introduceți desemnarea,
-Please login as a Marketplace User to edit this item.,Vă rugăm să vă autentificați ca utilizator de piață pentru a edita acest articol.,
-Please login as a Marketplace User to report this item.,Vă rugăm să vă autentificați ca utilizator de piață pentru a raporta acest articol.,
-Please select <b>Template Type</b> to download template,Vă rugăm să selectați <b>Tip de șablon</b> pentru a descărca șablonul,
-Please select Applicant Type first,Vă rugăm să selectați mai întâi tipul de solicitant,
-Please select Customer first,Vă rugăm să selectați Clientul mai întâi,
-Please select Item Code first,Vă rugăm să selectați mai întâi Codul articolului,
-Please select Loan Type for company {0},Vă rugăm să selectați Tip de împrumut pentru companie {0},
-Please select a Delivery Note,Vă rugăm să selectați o notă de livrare,
-Please select a Sales Person for item: {0},Vă rugăm să selectați o persoană de vânzări pentru articol: {0},
-Please select another payment method. Stripe does not support transactions in currency '{0}',Selectați o altă metodă de plată. Stripe nu acceptă tranzacțiile în valută &quot;{0}&quot;,
-Please select the customer.,Vă rugăm să selectați clientul.,
-Please set a Supplier against the Items to be considered in the Purchase Order.,Vă rugăm să setați un furnizor împotriva articolelor care trebuie luate în considerare în comanda de achiziție.,
-Please set account heads in GST Settings for Compnay {0},Vă rugăm să setați capetele de cont în Setările GST pentru Compnay {0},
-Please set an email id for the Lead {0},Vă rugăm să setați un cod de e-mail pentru Lead {0},
-Please set default UOM in Stock Settings,Vă rugăm să setați UOM implicit în Setări stoc,
-Please set filter based on Item or Warehouse due to a large amount of entries.,Vă rugăm să setați filtrul în funcție de articol sau depozit datorită unei cantități mari de înregistrări.,
-Please set up the Campaign Schedule in the Campaign {0},Vă rugăm să configurați Planificarea Campaniei în Campania {0},
-Please set valid GSTIN No. in Company Address for company {0},Vă rugăm să setați numărul GSTIN valid în adresa companiei pentru compania {0},
-Please set {0},Vă rugăm să setați {0},customer
-Please setup a default bank account for company {0},Vă rugăm să configurați un cont bancar implicit pentru companie {0},
-Please specify,Vă rugăm să specificați,
-Please specify a {0},Vă rugăm să specificați un {0},lead
-Pledge Status,Starea gajului,
-Pledge Time,Timp de gaj,
-Printing,Tipărire,
-Priority,Prioritate,
-Priority has been changed to {0}.,Prioritatea a fost modificată la {0}.,
-Priority {0} has been repeated.,Prioritatea {0} a fost repetată.,
-Processing XML Files,Procesarea fișierelor XML,
-Profitability,Rentabilitatea,
-Project,Proiect,
-Proposed Pledges are mandatory for secured Loans,Promisiunile propuse sunt obligatorii pentru împrumuturile garantate,
-Provide the academic year and set the starting and ending date.,Furnizați anul universitar și stabiliți data de început și de încheiere.,
-Public token is missing for this bank,Jurnalul public lipsește pentru această bancă,
-Publish,Publica,
-Publish 1 Item,Publicați 1 articol,
-Publish Items,Publica articole,
-Publish More Items,Publicați mai multe articole,
-Publish Your First Items,Publicați primele dvs. articole,
-Publish {0} Items,Publicați {0} articole,
-Published Items,Articole publicate,
-Purchase Invoice cannot be made against an existing asset {0},Factura de cumpărare nu poate fi făcută cu un activ existent {0},
-Purchase Invoices,Facturi de cumpărare,
-Purchase Orders,Ordine de achiziție,
-Purchase Receipt doesn't have any Item for which Retain Sample is enabled.,Încasarea de cumpărare nu are niciun articol pentru care este activat eșantionul de păstrare.,
-Purchase Return,Înapoi cumpărare,
-Qty of Finished Goods Item,Cantitatea articolului de produse finite,
-Qty or Amount is mandatroy for loan security,Cantitatea sau suma este mandatroy pentru securitatea împrumutului,
-Quality Inspection required for Item {0} to submit,Inspecția de calitate necesară pentru trimiterea articolului {0},
-Quantity to Manufacture,Cantitate de fabricare,
-Quantity to Manufacture can not be zero for the operation {0},Cantitatea de fabricație nu poate fi zero pentru operațiune {0},
-Quarterly,Trimestrial,
-Queued,Coada de așteptare,
-Quick Entry,Intrarea rapidă,
-Quiz {0} does not exist,Chestionarul {0} nu există,
-Quotation Amount,Suma ofertei,
-Rate or Discount is required for the price discount.,Tariful sau Reducerea este necesară pentru reducerea prețului.,
-Reason,Motiv,
-Reconcile Entries,Reconciliați intrările,
-Reconcile this account,Reconciliați acest cont,
-Reconciled,reconciliat,
-Recruitment,Recrutare,
-Red,Roșu,
-Refreshing,Împrospătare,
-Release date must be in the future,Data lansării trebuie să fie în viitor,
-Relieving Date must be greater than or equal to Date of Joining,Data scutirii trebuie să fie mai mare sau egală cu data aderării,
-Rename,Redenumire,
-Rename Not Allowed,Redenumirea nu este permisă,
-Repayment Method is mandatory for term loans,Metoda de rambursare este obligatorie pentru împrumuturile la termen,
-Repayment Start Date is mandatory for term loans,Data de începere a rambursării este obligatorie pentru împrumuturile la termen,
-Report Item,Raport articol,
-Report this Item,Raportați acest articol,
-Reserved Qty for Subcontract: Raw materials quantity to make subcontracted items.,Cantitate rezervată pentru subcontract: cantitate de materii prime pentru a face obiecte subcontractate.,
-Reset,Resetează,
-Reset Service Level Agreement,Resetați Acordul privind nivelul serviciilor,
-Resetting Service Level Agreement.,Resetarea Acordului privind nivelul serviciilor.,
-Return amount cannot be greater unclaimed amount,Suma returnată nu poate fi o sumă nereclamată mai mare,
-Review,Revizuire,
-Room,Cameră,
-Room Type,Tip Cameră,
-Row # ,Rând #,
-Row #{0}: Accepted Warehouse and Supplier Warehouse cannot be same,Rândul # {0}: depozitul acceptat și depozitul furnizorului nu pot fi aceleași,
-Row #{0}: Cannot delete item {1} which has already been billed.,Rândul # {0}: Nu se poate șterge elementul {1} care a fost deja facturat.,
-Row #{0}: Cannot delete item {1} which has already been delivered,Rândul # {0}: Nu se poate șterge articolul {1} care a fost deja livrat,
-Row #{0}: Cannot delete item {1} which has already been received,Rândul # {0}: Nu se poate șterge elementul {1} care a fost deja primit,
-Row #{0}: Cannot delete item {1} which has work order assigned to it.,Rândul # {0}: Nu se poate șterge elementul {1} care i-a fost atribuită o ordine de lucru.,
-Row #{0}: Cannot delete item {1} which is assigned to customer's purchase order.,Rândul # {0}: Nu se poate șterge articolul {1} care este atribuit comenzii de cumpărare a clientului.,
-Row #{0}: Cannot select Supplier Warehouse while suppling raw materials to subcontractor,Rândul # {0}: Nu se poate selecta Furnizorul în timp ce furnizează materii prime subcontractantului,
-Row #{0}: Cost Center {1} does not belong to company {2},Rândul {{0}: Centrul de costuri {1} nu aparține companiei {2},
-Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order {3}. Please update operation status via Job Card {4}.,Rândul # {0}: Operația {1} nu este finalizată pentru {2} cantitate de mărfuri finite în Ordinul de lucru {3}. Vă rugăm să actualizați starea operației prin intermediul cărții de lucru {4}.,
-Row #{0}: Payment document is required to complete the transaction,Rândul # {0}: documentul de plată este necesar pentru a finaliza tranzacția,
-Row #{0}: Serial No {1} does not belong to Batch {2},Rândul # {0}: nr. De serie {1} nu aparține lotului {2},
-Row #{0}: Service End Date cannot be before Invoice Posting Date,Rândul # {0}: Data de încheiere a serviciului nu poate fi înainte de Data de înregistrare a facturii,
-Row #{0}: Service Start Date cannot be greater than Service End Date,Rândul # {0}: Data de începere a serviciului nu poate fi mai mare decât Data de încheiere a serviciului,
-Row #{0}: Service Start and End Date is required for deferred accounting,Rândul # {0}: Data de început și de încheiere a serviciului este necesară pentru contabilitate amânată,
-Row {0}: Invalid Item Tax Template for item {1},Rândul {0}: șablonul de impozit pe articol nevalid pentru articolul {1},
-Row {0}: Quantity not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Rândul {0}: cantitatea nu este disponibilă pentru {4} în depozit {1} la momentul înregistrării la intrare ({2} {3}),
-Row {0}: user has not applied the rule {1} on the item {2},Rândul {0}: utilizatorul nu a aplicat regula {1} pe articolul {2},
-Row {0}:Sibling Date of Birth cannot be greater than today.,Rândul {0}: Data nașterii în materie nu poate fi mai mare decât astăzi.,
-Row({0}): {1} is already discounted in {2},Rândul ({0}): {1} este deja actualizat în {2},
-Rows Added in {0},Rânduri adăugate în {0},
-Rows Removed in {0},Rândurile eliminate în {0},
-Sanctioned Amount limit crossed for {0} {1},Limita sumei sancționate depășită pentru {0} {1},
-Sanctioned Loan Amount already exists for {0} against company {1},Suma de împrumut sancționat există deja pentru {0} față de compania {1},
-Save,Salvează,
-Save Item,Salvare articol,
-Saved Items,Articole salvate,
-Search Items ...,Caută articole ...,
-Search for a payment,Căutați o plată,
-Search for anything ...,Căutați orice ...,
-Search results for,cauta rezultate pentru,
-Select All,Selectează toate,
-Select Difference Account,Selectați Cont de diferență,
-Select a Default Priority.,Selectați o prioritate implicită.,
-Select a company,Selectați o companie,
-Select finance book for the item {0} at row {1},Selectați cartea de finanțe pentru articolul {0} din rândul {1},
-Select only one Priority as Default.,Selectați doar o prioritate ca implicită.,
-Seller Information,Informatiile vanzatorului,
-Send,Trimiteți,
-Send a message,Trimite un mesaj,
-Sending,Trimitere,
-Sends Mails to lead or contact based on a Campaign schedule,Trimite e-mailuri pentru a conduce sau a contacta pe baza unui program de campanie,
-Serial Number Created,Număr de serie creat,
-Serial Numbers Created,Numere de serie create,
-Serial no(s) required for serialized item {0},Numărul (numerele) de serie necesare pentru articolul serializat {0},
-Series,Serii,
-Server Error,Eroare de server,
-Service Level Agreement has been changed to {0}.,Acordul privind nivelul serviciilor a fost modificat în {0}.,
-Service Level Agreement was reset.,Acordul privind nivelul serviciilor a fost resetat.,
-Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Acordul privind nivelul serviciului cu tipul de entitate {0} și entitatea {1} există deja.,
-Set,Setează,
-Set Meta Tags,Setați etichete meta,
-Set {0} in company {1},Setați {0} în companie {1},
-Setup,Configurare,
-Setup Wizard,Vrăjitor Configurare,
-Shift Management,Managementul schimbării,
-Show Future Payments,Afișați plăți viitoare,
-Show Linked Delivery Notes,Afișare Note de livrare conexe,
-Show Sales Person,Afișați persoana de vânzări,
-Show Stock Ageing Data,Afișează date de îmbătrânire a stocurilor,
-Show Warehouse-wise Stock,Afișați stocul înțelept,
-Size,Dimensiune,
-Something went wrong while evaluating the quiz.,Ceva nu a mers în timp ce evaluați testul.,
-Sr,sr,
-Start,Început(Pornire),
-Start Date cannot be before the current date,Data de început nu poate fi înainte de data curentă,
-Start Time,Ora de începere,
-Status,Status,
-Status must be Cancelled or Completed,Starea trebuie anulată sau completată,
-Stock Balance Report,Raportul soldului stocurilor,
-Stock Entry has been already created against this Pick List,Intrarea pe stoc a fost deja creată pe baza acestei liste de alegeri,
-Stock Ledger ID,ID evidență stoc,
-Stock Value ({0}) and Account Balance ({1}) are out of sync for account {2} and it's linked warehouses.,Valoarea stocului ({0}) și soldul contului ({1}) nu sunt sincronizate pentru contul {2} și sunt depozite legate.,
-Stores - {0},Magazine - {0},
-Student with email {0} does not exist,Studentul cu e-mail {0} nu există,
-Submit Review,Trimite recenzie,
-Submitted,Inscrisa,
-Supplier Addresses And Contacts,Adrese furnizorului și de Contacte,
-Synchronize this account,Sincronizați acest cont,
-Tag,Etichetă,
-Target Location is required while receiving Asset {0} from an employee,Locația țintă este necesară în timp ce primiți activ {0} de la un angajat,
-Target Location is required while transferring Asset {0},Locația țintă este necesară în timpul transferului de active {0},
-Target Location or To Employee is required while receiving Asset {0},Locația țintei sau către angajat este necesară în timp ce primiți activ {0},
-Task's {0} End Date cannot be after Project's End Date.,Data de încheiere a sarcinii {0} nu poate fi după data de încheiere a proiectului.,
-Task's {0} Start Date cannot be after Project's End Date.,Data de început a sarcinii {0} nu poate fi după data de încheiere a proiectului.,
-Tax Account not specified for Shopify Tax {0},Contul fiscal nu este specificat pentru Shopify Tax {0},
-Tax Total,Total impozit,
-Template,Șablon,
-The Campaign '{0}' already exists for the {1} '{2}',Campania „{0}” există deja pentru {1} &#39;{2}&#39;,
-The difference between from time and To Time must be a multiple of Appointment,Diferența dintre timp și To Time trebuie să fie multiplu de numire,
-The field Asset Account cannot be blank,Câmpul Contul de active nu poate fi gol,
-The field Equity/Liability Account cannot be blank,Câmpul Contul de capitaluri proprii / pasiv nu poate fi necompletat,
-The following serial numbers were created: <br><br> {0},Au fost create următoarele numere de serie: <br><br> {0},
-The parent account {0} does not exists in the uploaded template,Contul părinte {0} nu există în șablonul încărcat,
-The question cannot be duplicate,Întrebarea nu poate fi duplicată,
-The selected payment entry should be linked with a creditor bank transaction,Intrarea de plată selectată trebuie să fie legată de o tranzacție bancară cu creditor,
-The selected payment entry should be linked with a debtor bank transaction,Intrarea de plată selectată trebuie să fie legată de o tranzacție bancară cu debitori,
-The total allocated amount ({0}) is greated than the paid amount ({1}).,Suma totală alocată ({0}) este majorată decât suma plătită ({1}).,
-There are no vacancies under staffing plan {0},Nu există locuri vacante conform planului de personal {0},
-This Service Level Agreement is specific to Customer {0},Acest Acord de nivel de serviciu este specific Clientului {0},
-This action will unlink this account from any external service integrating ERPNext with your bank accounts. It cannot be undone. Are you certain ?,Această acțiune va deconecta acest cont de orice serviciu extern care integrează ERPNext cu conturile dvs. bancare. Nu poate fi anulată. Esti sigur ?,
-This bank account is already synchronized,Acest cont bancar este deja sincronizat,
-This bank transaction is already fully reconciled,Această tranzacție bancară este deja complet reconciliată,
-This employee already has a log with the same timestamp.{0},Acest angajat are deja un jurnal cu aceeași oră de timp. {0},
-This page keeps track of items you want to buy from sellers.,Această pagină ține evidența articolelor pe care doriți să le cumpărați de la vânzători.,
-This page keeps track of your items in which buyers have showed some interest.,Această pagină ține evidența articolelor dvs. pentru care cumpărătorii au arătat interes.,
-Thursday,Joi,
-Timing,Sincronizare,
-Title,Titlu,
-"To allow over billing, update ""Over Billing Allowance"" in Accounts Settings or the Item.","Pentru a permite facturarea excesivă, actualizați „Indemnizație de facturare” în Setări conturi sau element.",
-"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Pentru a permite primirea / livrarea, actualizați „Indemnizația de primire / livrare” în Setări de stoc sau articol.",
-To date needs to be before from date,Până în prezent trebuie să fie înainte de această dată,
-Total,Total,
-Total Early Exits,Total Ieșiri anticipate,
-Total Late Entries,Total intrări târzii,
-Total Payment Request amount cannot be greater than {0} amount,Suma totală a solicitării de plată nu poate fi mai mare decât {0},
-Total payments amount can't be greater than {},Valoarea totală a plăților nu poate fi mai mare de {},
-Totals,Totaluri,
-Training Event:,Eveniment de formare:,
-Transactions already retreived from the statement,Tranzacțiile au fost retrase din extras,
-Transfer Material to Supplier,Transfer de material la furnizor,
-Transport Receipt No and Date are mandatory for your chosen Mode of Transport,Numărul de recepție și data de transport nu sunt obligatorii pentru modul de transport ales,
-Tuesday,Marți,
-Type,Tip,
-Unable to find Salary Component {0},Imposibil de găsit componentul salariului {0},
-Unable to find the time slot in the next {0} days for the operation {1}.,Nu se poate găsi intervalul orar în următoarele {0} zile pentru operația {1}.,
-Unable to update remote activity,Imposibil de actualizat activitatea de la distanță,
-Unknown Caller,Apelant necunoscut,
-Unlink external integrations,Deconectați integrările externe,
-Unmarked Attendance for days,Participarea nemarcată zile întregi,
-Unpublish Item,Publicarea articolului,
-Unreconciled,nereconciliat,
-Unsupported GST Category for E-Way Bill JSON generation,Categorie GST neacceptată pentru generarea JSON Bill E-Way,
-Update,Actualizare,
-Update Details,Detalii detalii,
-Update Taxes for Items,Actualizați impozitele pentru articole,
-"Upload a bank statement, link or reconcile a bank account","Încărcați un extras bancar, conectați sau reconciliați un cont bancar",
-Upload a statement,Încărcați o declarație,
-Use a name that is different from previous project name,Utilizați un nume diferit de numele proiectului anterior,
-User {0} is disabled,Utilizatorul {0} este dezactivat,
-Users and Permissions,Utilizatori și permisiuni,
-Vacancies cannot be lower than the current openings,Posturile vacante nu pot fi mai mici decât deschiderile actuale,
-Valid From Time must be lesser than Valid Upto Time.,Valid From Time trebuie să fie mai mic decât Valid Upto Time.,
-Valuation Rate required for Item {0} at row {1},Rata de evaluare necesară pentru articolul {0} la rândul {1},
-Values Out Of Sync,Valori ieșite din sincronizare,
-Vehicle Type is required if Mode of Transport is Road,Tip de vehicul este necesar dacă modul de transport este rutier,
-Vendor Name,Numele vânzătorului,
-Verify Email,Verificați e-mail,
-View,Vedere,
-View all issues from {0},Vedeți toate problemele din {0},
-View call log,Vizualizați jurnalul de apeluri,
-Warehouse,Depozit,
-Warehouse not found against the account {0},Depozitul nu a fost găsit în contul {0},
-Welcome to {0},Bine ai venit la {0},
-Why do think this Item should be removed?,De ce credeți că acest articol ar trebui eliminat?,
-Work Order {0}: Job Card not found for the operation {1},Comandă de lucru {0}: cartea de muncă nu a fost găsită pentru operație {1},
-Workday {0} has been repeated.,Ziua lucrătoare {0} a fost repetată.,
-XML Files Processed,Fișiere XML procesate,
-Year,An,
-Yearly,Anual,
-You,Tu,
-You are not allowed to enroll for this course,Nu aveți voie să vă înscrieți la acest curs,
-You are not enrolled in program {0},Nu sunteți înscris în programul {0},
-You can Feature upto 8 items.,Puteți prezenta până la 8 articole.,
-You can also copy-paste this link in your browser,"De asemenea, puteți să copiați-paste această legătură în browser-ul dvs.",
-You can publish upto 200 items.,Puteți publica până la 200 de articole.,
-You have to enable auto re-order in Stock Settings to maintain re-order levels.,Trebuie să activați re-comanda auto în Setări stoc pentru a menține nivelurile de re-comandă.,
-You must be a registered supplier to generate e-Way Bill,Pentru a genera Bill e-Way trebuie să fiți un furnizor înregistrat,
-You need to login as a Marketplace User before you can add any reviews.,Trebuie să vă autentificați ca utilizator de piață înainte de a putea adăuga recenzii.,
-Your Featured Items,Articolele dvs. recomandate,
-Your Items,Articolele dvs.,
-Your Profile,Profilul tau,
-Your rating:,Rating-ul tău:,
-and,și,
-e-Way Bill already exists for this document,e-Way Bill există deja pentru acest document,
-woocommerce - {0},woocommerce - {0},
-{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Cuponul utilizat este {1}. Cantitatea admisă este epuizată,
-{0} Name,{0} Nume,
-{0} Operations: {1},{0} Operații: {1},
-{0} bank transaction(s) created,{0} tranzacțiile bancare create,
-{0} bank transaction(s) created and {1} errors,{0} tranzacțiile bancare create și {1} erori,
-{0} can not be greater than {1},{0} nu poate fi mai mare de {1},
-{0} conversations,{0} conversații,
-{0} is not a company bank account,{0} nu este un cont bancar al companiei,
-{0} is not a group node. Please select a group node as parent cost center,{0} nu este un nod de grup. Vă rugăm să selectați un nod de grup ca centru de costuri parentale,
-{0} is not the default supplier for any items.,{0} nu este furnizorul prestabilit pentru niciun articol.,
-{0} is required,{0} este necesar,
-{0}: {1} must be less than {2},{0}: {1} trebuie să fie mai mic decât {2},
-{} is an invalid Attendance Status.,{} este o stare de prezență nevalidă.,
-{} is required to generate E-Way Bill JSON,{} este necesar pentru a genera Bill JSON E-Way,
-"Invalid lost reason {0}, please create a new lost reason","Motiv pierdut nevalabil {0}, vă rugăm să creați un motiv nou pierdut",
-Profit This Year,Profit anul acesta,
-Total Expense,Cheltuieli totale,
-Total Expense This Year,Cheltuieli totale în acest an,
-Total Income,Venit total,
-Total Income This Year,Venit total în acest an,
-Barcode,coduri de bare,
-Bold,Îndrăzneţ,
-Center,Centru,
-Clear,clar,
-Comment,cometariu,
-Comments,Comentarii,
-DocType,DocType,
-Download,Descarca,
-Left,Stânga,
-Link,Legătură,
-New,Nou,
-Not Found,Nu a fost găsit,
-Print,Imprimare,
-Reference Name,nume de referinta,
-Refresh,Actualizare,
-Success,Succes,
-Time,Timp,
-Value,Valoare,
-Actual,Real,
-Add to Cart,Adăugaţi în Coş,
-Days Since Last Order,Zile de la ultima comandă,
-In Stock,In stoc,
-Loan Amount is mandatory,Suma împrumutului este obligatorie,
-Mode Of Payment,Modul de plată,
-No students Found,Nu au fost găsiți studenți,
-Not in Stock,Nu este în stoc,
-Please select a Customer,Selectați un client,
-Printed On,imprimat pe,
-Received From,Primit de la,
-Sales Person,Persoană de vânzări,
-To date cannot be before From date,Până în prezent nu poate fi înainte de data,
-Write Off,Achita,
-{0} Created,{0} a fost creat,
-Email Id,ID-ul de e-mail,
-No,Nu,
-Reference Doctype,DocType referință,
-User Id,Numele de utilizator,
-Yes,da,
-Actual ,Efectiv,
-Add to cart,Adăugaţi în Coş,
-Budget,Buget,
-Chart of Accounts,Grafic de conturi,
-Customer database.,Baza de date pentru clienți.,
-Days Since Last order,Zile de la ultima comandă,
-Download as JSON,Descărcați ca JSON,
-End date can not be less than start date,Data de Incheiere nu poate fi anterioara Datei de Incepere,
-For Default Supplier (Optional),Pentru furnizor implicit (opțional),
-From date cannot be greater than To date,De la data nu poate fi mai mare decât la data,
-Group by,Grupul De,
-In stock,In stoc,
-Item name,Denumire Articol,
-Loan amount is mandatory,Suma împrumutului este obligatorie,
-Minimum Qty,Cantitatea minimă,
-More details,Mai multe detalii,
-Nature of Supplies,Natura aprovizionării,
-No Items found.,Nu au fost gasite articolele.,
-No employee found,Nu a fost găsit angajat,
-No students found,Nu există elevi găsit,
-Not in stock,Nu este în stoc,
-Not permitted,Nu sunt acceptate,
-Open Issues ,Probleme deschise,
-Open Projects ,Deschide Proiecte,
-Open To Do ,Deschideți To Do,
-Operation Id,Operațiunea ID,
-Partially ordered,Comandat parțial,
-Please select company first,Selectați prima companie,
-Please select patient,Selectați pacientul,
-Printed On ,Tipărit pe,
-Projected qty,Numărul estimat,
-Sales person,Persoană de vânzări,
-Serial No {0} Created,Serial Nu {0} a creat,
-Source Location is required for the Asset {0},Sursa Locația este necesară pentru elementul {0},
-Tax Id,Cod de identificare fiscală,
-To Time,La timp,
-To date cannot be before from date,Până în prezent nu poate fi înainte de De la dată,
-Total Taxable value,Valoarea impozabilă totală,
-Upcoming Calendar Events ,Evenimente viitoare Calendar,
-Value or Qty,Valoare sau cantitate,
-Variance ,variație,
-Variant of,Varianta de,
-Write off,Achita,
-hours,ore,
-received from,primit de la,
-to,Până la data,
-Cards,Carduri,
-Percentage,Procent,
-Failed to setup defaults for country {0}. Please contact support@erpnext.com,Eroare la configurarea valorilor prestabilite pentru țară {0}. Vă rugăm să contactați support@erpnext.com,
-Row #{0}: Item {1} is not a Serialized/Batched Item. It cannot have a Serial No/Batch No against it.,Rândul # {0}: Elementul {1} nu este un articol serializat / batat. Nu poate avea un număr de serie / nr.,
-Please set {0},Vă rugăm să setați {0},
-Please set {0},Vă rugăm să setați {0},supplier
-Draft,Proiect,"docstatus,=,0"
-Cancelled,Anulat,"docstatus,=,2"
-Please setup Instructor Naming System in Education > Education Settings,Vă rugăm să configurați sistemul de numire a instructorului în educație&gt; Setări educație,
-Please set Naming Series for {0} via Setup > Settings > Naming Series,Vă rugăm să setați Naming Series pentru {0} prin Setare&gt; Setări&gt; Serie pentru denumire,
-UOM Conversion factor ({0} -> {1}) not found for item: {2},Factorul de conversie UOM ({0} -&gt; {1}) nu a fost găsit pentru articol: {2},
-Item Code > Item Group > Brand,Cod articol&gt; Grup de articole&gt; Marcă,
-Customer > Customer Group > Territory,Client&gt; Grup de clienți&gt; Teritoriul,
-Supplier > Supplier Type,Furnizor&gt; Tip furnizor,
-Please setup Employee Naming System in Human Resource > HR Settings,Vă rugăm să configurați sistemul de numire a angajaților în resurse umane&gt; Setări HR,
-Please setup numbering series for Attendance via Setup > Numbering Series,Vă rugăm să configurați seria de numerotare pentru prezență prin Setare&gt; Numerotare,
-The value of {0} differs between Items {1} and {2},Valoarea {0} diferă între elementele {1} și {2},
-Auto Fetch,Preluare automată,
-Fetch Serial Numbers based on FIFO,Obțineți numerele de serie pe baza FIFO,
-"Outward taxable supplies(other than zero rated, nil rated and exempted)","Consumabile impozabile (altele decât zero, zero și scutite)",
-"To allow different rates, disable the {0} checkbox in {1}.","Pentru a permite tarife diferite, dezactivați caseta de selectare {0} din {1}.",
-Current Odometer Value should be greater than Last Odometer Value {0},Valoarea curentă a kilometrului ar trebui să fie mai mare decât ultima valoare a kilometrului {0},
-No additional expenses has been added,Nu s-au adăugat cheltuieli suplimentare,
-Asset{} {assets_link} created for {},Element {} {assets_link} creat pentru {},
-Row {}: Asset Naming Series is mandatory for the auto creation for item {},Rând {}: Seria de denumire a activelor este obligatorie pentru crearea automată a articolului {},
-Assets not created for {0}. You will have to create asset manually.,Elemente care nu au fost create pentru {0}. Va trebui să creați manual activul.,
-{0} {1} has accounting entries in currency {2} for company {3}. Please select a receivable or payable account with currency {2}.,{0} {1} are înregistrări contabile în valută {2} pentru companie {3}. Vă rugăm să selectați un cont de primit sau de plătit cu moneda {2}.,
-Invalid Account,Cont invalid,
-Purchase Order Required,Comandă de aprovizionare necesare,
-Purchase Receipt Required,Cumpărare de primire Obligatoriu,
-Account Missing,Cont lipsă,
-Requested,Solicitată,
-Partially Paid,Parțial plătit,
-Invalid Account Currency,Moneda contului este nevalidă,
-"Row {0}: The item {1}, quantity must be positive number","Rândul {0}: elementul {1}, cantitatea trebuie să fie un număr pozitiv",
-"Please set {0} for Batched Item {1}, which is used to set {2} on Submit.","Vă rugăm să setați {0} pentru articolul lot {1}, care este utilizat pentru a seta {2} la Trimitere.",
-Expiry Date Mandatory,Data de expirare Obligatorie,
-Variant Item,Variant Item,
-BOM 1 {0} and BOM 2 {1} should not be same,BOM 1 {0} și BOM 2 {1} nu ar trebui să fie aceleași,
-Note: Item {0} added multiple times,Notă: articolul {0} a fost adăugat de mai multe ori,
-YouTube,YouTube,
-Vimeo,Vimeo,
-Publish Date,Data publicării,
-Duration,Durată,
-Advanced Settings,Setari avansate,
-Path,cale,
-Components,Componente,
-Verified By,Verificate de,
-Invalid naming series (. missing) for {0},Serii de denumiri nevalide (. Lipsesc) pentru {0},
-Filter Based On,Filtrare bazată pe,
-Reqd by date,Reqd după dată,
-Manufacturer Part Number <b>{0}</b> is invalid,Numărul de piesă al producătorului <b>{0}</b> este nevalid,
-Invalid Part Number,Număr de piesă nevalid,
-Select atleast one Social Media from Share on.,Selectați cel puțin o rețea socială din Partajare pe.,
-Invalid Scheduled Time,Ora programată nevalidă,
-Length Must be less than 280.,Lungimea trebuie să fie mai mică de 280.,
-Error while POSTING {0},Eroare la POSTARE {0},
-"Session not valid, Do you want to login?","Sesiunea nu este validă, doriți să vă autentificați?",
-Session Active,Sesiune activă,
-Session Not Active. Save doc to login.,Sesiunea nu este activă. Salvați documentul pentru autentificare.,
-Error! Failed to get request token.,Eroare! Nu s-a obținut indicativul de solicitare,
-Invalid {0} or {1},{0} sau {1} nevalid,
-Error! Failed to get access token.,Eroare! Nu s-a obținut jetonul de acces.,
-Invalid Consumer Key or Consumer Secret Key,Cheie consumator nevalidă sau cheie secretă consumator,
-Your Session will be expire in ,Sesiunea dvs. va expira în,
- days.,zile.,
-Session is expired. Save doc to login.,Sesiunea a expirat. Salvați documentul pentru autentificare.,
-Error While Uploading Image,Eroare la încărcarea imaginii,
-You Didn't have permission to access this API,Nu ați avut permisiunea de a accesa acest API,
-Valid Upto date cannot be before Valid From date,Valid Upto date nu poate fi înainte de Valid From date,
-Valid From date not in Fiscal Year {0},Valabil de la data care nu se află în anul fiscal {0},
-Valid Upto date not in Fiscal Year {0},Data actualizată valabilă nu în anul fiscal {0},
-Group Roll No,Rola grupului nr,
-Maintain Same Rate Throughout Sales Cycle,Menține Aceeași Rată in Cursul Ciclului de Vânzări,
-"Row {1}: Quantity ({0}) cannot be a fraction. To allow this, disable '{2}' in UOM {3}.","Rândul {1}: Cantitatea ({0}) nu poate fi o fracțiune. Pentru a permite acest lucru, dezactivați „{2}” în UOM {3}.",
-Must be Whole Number,Trebuie să fie Număr întreg,
-Please setup Razorpay Plan ID,Configurați ID-ul planului Razorpay,
-Contact Creation Failed,Crearea contactului nu a reușit,
-{0} already exists for employee {1} and period {2},{0} există deja pentru angajat {1} și perioada {2},
-Leaves Allocated,Frunze alocate,
-Leaves Expired,Frunzele au expirat,
-Leave Without Pay does not match with approved {} records,Concediu fără plată nu se potrivește cu înregistrările {} aprobate,
-Income Tax Slab not set in Salary Structure Assignment: {0},Placa de impozit pe venit nu este setată în atribuirea structurii salariale: {0},
-Income Tax Slab: {0} is disabled,Planșa impozitului pe venit: {0} este dezactivat,
-Income Tax Slab must be effective on or before Payroll Period Start Date: {0},Placa pentru impozitul pe venit trebuie să fie efectivă la data de începere a perioadei de salarizare sau înainte de aceasta: {0},
-No leave record found for employee {0} on {1},Nu s-a găsit nicio evidență de concediu pentru angajatul {0} pe {1},
-Row {0}: {1} is required in the expenses table to book an expense claim.,Rândul {0}: {1} este necesar în tabelul de cheltuieli pentru a rezerva o cerere de cheltuieli.,
-Set the default account for the {0} {1},Setați contul prestabilit pentru {0} {1},
-(Half Day),(Jumătate de zi),
-Income Tax Slab,Placa impozitului pe venit,
-Row #{0}: Cannot set amount or formula for Salary Component {1} with Variable Based On Taxable Salary,Rândul # {0}: Nu se poate stabili suma sau formula pentru componenta salariu {1} cu variabilă pe baza salariului impozabil,
-Row #{}: {} of {} should be {}. Please modify the account or select a different account.,Rândul # {}: {} din {} ar trebui să fie {}. Vă rugăm să modificați contul sau să selectați un alt cont.,
-Row #{}: Please asign task to a member.,Rândul # {}: atribuiți sarcina unui membru.,
-Process Failed,Procesul nu a reușit,
-Tally Migration Error,Eroare de migrare Tally,
-Please set Warehouse in Woocommerce Settings,Vă rugăm să setați Depozitul în Setările Woocommerce,
-Row {0}: Delivery Warehouse ({1}) and Customer Warehouse ({2}) can not be same,Rândul {0}: Depozitul de livrare ({1}) și Depozitul pentru clienți ({2}) nu pot fi identice,
-Row {0}: Due Date in the Payment Terms table cannot be before Posting Date,Rândul {0}: Data scadenței din tabelul Condiții de plată nu poate fi înainte de Data înregistrării,
-Cannot find {} for item {}. Please set the same in Item Master or Stock Settings.,Nu se poate găsi {} pentru articol {}. Vă rugăm să setați același lucru în Setări articol principal sau stoc,
-Row #{0}: The batch {1} has already expired.,Rândul # {0}: lotul {1} a expirat deja.,
-Start Year and End Year are mandatory,Anul de început și anul de sfârșit sunt obligatorii,
-GL Entry,Intrari GL,
-Cannot allocate more than {0} against payment term {1},Nu se pot aloca mai mult de {0} contra termenului de plată {1},
-The root account {0} must be a group,Contul rădăcină {0} trebuie să fie un grup,
-Shipping rule not applicable for country {0} in Shipping Address,Regula de expediere nu se aplică pentru țara {0} din adresa de expediere,
-Get Payments from,Primiți plăți de la,
-Set Shipping Address or Billing Address,Setați adresa de expediere sau adresa de facturare,
-Consultation Setup,Configurarea consultării,
-Fee Validity,Valabilitate taxă,
-Laboratory Setup,Configurarea laboratorului,
-Dosage Form,Formă de dozare,
-Records and History,Înregistrări și istorie,
-Patient Medical Record,Dosarul medical al pacientului,
-Rehabilitation,Reabilitare,
-Exercise Type,Tipul de exercițiu,
-Exercise Difficulty Level,Nivelul de dificultate al exercițiului,
-Therapy Type,Tip de terapie,
-Therapy Plan,Planul de terapie,
-Therapy Session,Sesiune de terapie,
-Motor Assessment Scale,Scara de evaluare motorie,
-[Important] [ERPNext] Auto Reorder Errors,[Important] [ERPNext] Erori de reordonare automată,
-"Regards,","Salutari,",
-The following {0} were created: {1},Au fost create următoarele {0}: {1},
-Work Orders,comenzi de lucru,
-The {0} {1} created sucessfully,{0} {1} a fost creat cu succes,
-Work Order cannot be created for following reason: <br> {0},Ordinea de lucru nu poate fi creată din următorul motiv:<br> {0},
-Add items in the Item Locations table,Adăugați elemente în tabelul Locații element,
-Update Current Stock,Actualizați stocul curent,
-"{0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Păstrarea eșantionului se bazează pe lot, vă rugăm să bifați Are Batch No pentru a păstra eșantionul articolului",
-Empty,Gol,
-Currently no stock available in any warehouse,În prezent nu există stoc disponibil în niciun depozit,
-BOM Qty,Cantitatea BOM,
-Time logs are required for {0} {1},Jurnalele de timp sunt necesare pentru {0} {1},
-Total Completed Qty,Cantitatea totală completată,
-Qty to Manufacture,Cantitate pentru fabricare,
-Repay From Salary can be selected only for term loans,Rambursarea din salariu poate fi selectată numai pentru împrumuturile pe termen,
-No valid Loan Security Price found for {0},Nu s-a găsit un preț valid de securitate a împrumutului pentru {0},
-Loan Account and Payment Account cannot be same,Contul de împrumut și Contul de plată nu pot fi aceleași,
-Loan Security Pledge can only be created for secured loans,Garanția de securitate a împrumutului poate fi creată numai pentru împrumuturile garantate,
-Social Media Campaigns,Campanii de socializare,
-From Date can not be greater than To Date,From Date nu poate fi mai mare decât To Date,
-Please set a Customer linked to the Patient,Vă rugăm să setați un client legat de pacient,
-Customer Not Found,Clientul nu a fost găsit,
-Please Configure Clinical Procedure Consumable Item in ,Vă rugăm să configurați articolul consumabil pentru procedura clinică în,
-Missing Configuration,Configurare lipsă,
-Out Patient Consulting Charge Item,Aflați articolul de taxare pentru consultanță pentru pacient,
-Inpatient Visit Charge Item,Taxă pentru vizitarea pacientului,
-OP Consulting Charge,OP Taxă de consultanță,
-Inpatient Visit Charge,Taxă pentru vizitarea bolnavului,
-Appointment Status,Starea numirii,
-Test: ,Test:,
-Collection Details: ,Detalii colecție:,
-{0} out of {1},{0} din {1},
-Select Therapy Type,Selectați Tip de terapie,
-{0} sessions completed,{0} sesiuni finalizate,
-{0} session completed,{0} sesiune finalizată,
- out of {0},din {0},
-Therapy Sessions,Ședințe de terapie,
-Add Exercise Step,Adăugați Pasul de exerciții,
-Edit Exercise Step,Editați Pasul de exerciții,
-Patient Appointments,Programări pentru pacienți,
-Item with Item Code {0} already exists,Elementul cu codul articolului {0} există deja,
-Registration Fee cannot be negative or zero,Taxa de înregistrare nu poate fi negativă sau zero,
-Configure a service Item for {0},Configurați un articol de serviciu pentru {0},
-Temperature: ,Temperatura:,
-Pulse: ,Puls:,
-Respiratory Rate: ,Rata respiratorie:,
-BP: ,BP:,
-BMI: ,IMC:,
-Note: ,Notă:,
-Check Availability,Verifică Disponibilitate,
-Please select Patient first,Vă rugăm să selectați mai întâi Pacient,
-Please select a Mode of Payment first,Vă rugăm să selectați mai întâi un mod de plată,
-Please set the Paid Amount first,Vă rugăm să setați mai întâi suma plătită,
-Not Therapies Prescribed,Nu terapii prescrise,
-There are no Therapies prescribed for Patient {0},Nu există terapii prescrise pentru pacient {0},
-Appointment date and Healthcare Practitioner are Mandatory,Data numirii și medicul sunt obligatorii,
-No Prescribed Procedures found for the selected Patient,Nu s-au găsit proceduri prescrise pentru pacientul selectat,
-Please select a Patient first,Vă rugăm să selectați mai întâi un pacient,
-There are no procedure prescribed for ,Nu există o procedură prescrisă pentru,
-Prescribed Therapies,Terapii prescrise,
-Appointment overlaps with ,Programarea se suprapune cu,
-{0} has appointment scheduled with {1} at {2} having {3} minute(s) duration.,{0} are programată o întâlnire cu {1} la {2} cu o durată de {3} minute.,
-Appointments Overlapping,Programări care se suprapun,
-Consulting Charges: {0},Taxe de consultanță: {0},
-Appointment Cancelled. Please review and cancel the invoice {0},Programare anulată. Examinați și anulați factura {0},
-Appointment Cancelled.,Programare anulată.,
-Fee Validity {0} updated.,Valabilitatea taxei {0} actualizată.,
-Practitioner Schedule Not Found,Programul practicantului nu a fost găsit,
-{0} is on a Half day Leave on {1},{0} este într-un concediu de jumătate de zi pe {1},
-{0} is on Leave on {1},{0} este în concediu pe {1},
-{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner,{0} nu are un program de asistență medicală. Adăugați-l în Healthcare Practitioner,
-Healthcare Service Units,Unități de servicii medicale,
-Complete and Consume,Completează și consumă,
-Complete {0} and Consume Stock?,Completați {0} și consumați stoc?,
-Complete {0}?,Completați {0}?,
-Stock quantity to start the Procedure is not available in the Warehouse {0}. Do you want to record a Stock Entry?,Cantitatea de stoc pentru a începe procedura nu este disponibilă în depozit {0}. Doriți să înregistrați o înregistrare de stoc?,
-{0} as on {1},{0} ca pe {1},
-Clinical Procedure ({0}):,Procedură clinică ({0}):,
-Please set Customer in Patient {0},Vă rugăm să setați Clientul în Pacient {0},
-Item {0} is not active,Elementul {0} nu este activ,
-Therapy Plan {0} created successfully.,Planul de terapie {0} a fost creat cu succes.,
-Symptoms: ,Simptome:,
-No Symptoms,Fără simptome,
-Diagnosis: ,Diagnostic:,
-No Diagnosis,Fără diagnostic,
-Drug(s) Prescribed.,Medicament (e) prescris (e).,
-Test(s) Prescribed.,Test (e) prescris (e).,
-Procedure(s) Prescribed.,Procedură (proceduri) prescrise.,
-Counts Completed: {0},Număruri finalizate: {0},
-Patient Assessment,Evaluarea pacientului,
-Assessments,Evaluări,
-Heads (or groups) against which Accounting Entries are made and balances are maintained.,Heads (sau grupuri) față de care înregistrările contabile sunt făcute și soldurile sunt menținute.,
-Account Name,Numele Contului,
-Inter Company Account,Contul Companiei Inter,
-Parent Account,Contul părinte,
-Setting Account Type helps in selecting this Account in transactions.,Setarea Tipul de cont ajută în selectarea acest cont în tranzacții.,
-Chargeable,Taxabil/a,
-Rate at which this tax is applied,Rata la care se aplică acest impozit,
-Frozen,Blocat,
-"If the account is frozen, entries are allowed to restricted users.","În cazul în care contul este blocat, intrările sunt permite utilizatorilor restricționati.",
-Balance must be,Bilanţul trebuie să fie,
-Lft,Lft,
-Rgt,Rgt,
-Old Parent,Vechi mamă,
-Include in gross,Includeți în brut,
-Auditor,Auditor,
-Accounting Dimension,Dimensiunea contabilității,
-Dimension Name,Numele dimensiunii,
-Dimension Defaults,Valorile implicite ale dimensiunii,
-Accounting Dimension Detail,Detalii privind dimensiunea contabilității,
-Default Dimension,Dimensiunea implicită,
-Mandatory For Balance Sheet,Obligatoriu pentru bilanț,
-Mandatory For Profit and Loss Account,Obligatoriu pentru contul de profit și pierdere,
-Accounting Period,Perioadă Contabilă,
-Period Name,Numele perioadei,
-Closed Documents,Documente închise,
-Accounts Settings,Setări Conturi,
-Settings for Accounts,Setări pentru conturi,
-Make Accounting Entry For Every Stock Movement,Realizeaza Intrare de Contabilitate Pentru Fiecare Modificare a Stocului,
-Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Utilizatorii cu acest rol li se permite să stabilească în conturile înghețate și de a crea / modifica intrări contabile împotriva conturile înghețate,
-Determine Address Tax Category From,Determinați categoria de impozitare pe adresa de la,
-Over Billing Allowance (%),Indemnizație de facturare peste (%),
-Credit Controller,Controler de Credit,
-Check Supplier Invoice Number Uniqueness,Cec Furnizor Numărul facturii Unicitatea,
-Make Payment via Journal Entry,Efectuați o plată prin Jurnalul de intrare,
-Unlink Payment on Cancellation of Invoice,Plata unlink privind anularea facturii,
-Book Asset Depreciation Entry Automatically,Încărcarea automată a amortizării activelor din cont,
-Automatically Add Taxes and Charges from Item Tax Template,Adaugă automat impozite și taxe din șablonul de impozit pe articole,
-Automatically Fetch Payment Terms,Obțineți automat Termenii de plată,
-Show Payment Schedule in Print,Afișați programul de plată în Tipărire,
-Currency Exchange Settings,Setările de schimb valutar,
-Allow Stale Exchange Rates,Permiteți rate de schimb stale,
-Stale Days,Zilele stale,
-Report Settings,Setările raportului,
-Use Custom Cash Flow Format,Utilizați formatul fluxului de numerar personalizat,
-Allowed To Transact With,Permis pentru a tranzacționa cu,
-SWIFT number,Număr rapid,
-Branch Code,Codul filialei,
-Address and Contact,Adresa și Contact,
-Address HTML,Adresă HTML,
-Contact HTML,HTML Persoana de Contact,
-Data Import Configuration,Configurarea importului de date,
-Bank Transaction Mapping,Maparea tranzacțiilor bancare,
-Plaid Access Token,Token de acces la carouri,
-Company Account,Contul companiei,
-Account Subtype,Subtipul contului,
-Is Default Account,Este contul implicit,
-Is Company Account,Este un cont de companie,
-Party Details,Party Detalii,
-Account Details,Detalii cont,
-IBAN,IBAN,
-Bank Account No,Contul bancar nr,
-Integration Details,Detalii de integrare,
-Integration ID,ID de integrare,
-Last Integration Date,Ultima dată de integrare,
-Change this date manually to setup the next synchronization start date,Modificați această dată manual pentru a configura următoarea dată de început a sincronizării,
-Mask,Masca,
-Bank Account Subtype,Subtipul contului bancar,
-Bank Account Type,Tipul contului bancar,
-Bank Guarantee,Garantie bancara,
-Bank Guarantee Type,Tip de garanție bancară,
-Receiving,primire,
-Providing,Furnizarea,
-Reference Document Name,Numele documentului de referință,
-Validity in Days,Valabilitate în Zile,
-Bank Account Info,Informații despre contul bancar,
-Clauses and Conditions,Clauze și Condiții,
-Other Details,Alte detalii,
-Bank Guarantee Number,Numărul de garanție bancară,
-Name of Beneficiary,Numele beneficiarului,
-Margin Money,Marja de bani,
-Charges Incurred,Taxele incasate,
-Fixed Deposit Number,Numărul depozitului fix,
-Account Currency,Moneda cont,
-Select the Bank Account to reconcile.,Selectați contul bancar pentru a vă reconcilia.,
-Include Reconciled Entries,Includ intrările împăcat,
-Get Payment Entries,Participările de plată,
-Payment Entries,Intrările de plată,
-Update Clearance Date,Actualizare Clearance Data,
-Bank Reconciliation Detail,Detaliu reconciliere bancară,
-Cheque Number,Număr Cec,
-Cheque Date,Dată Cec,
-Statement Header Mapping,Afișarea antetului de rutare,
-Statement Headers,Antetele declarațiilor,
-Transaction Data Mapping,Transaction Data Mapping,
-Mapped Items,Elemente cartografiate,
-Bank Statement Settings Item,Elementul pentru setările declarației bancare,
-Mapped Header,Antet Cartografiat,
-Bank Header,Antetul băncii,
-Bank Statement Transaction Entry,Intrare tranzacție la declarația bancară,
-Bank Transaction Entries,Intrările de tranzacții bancare,
-New Transactions,Noi tranzacții,
-Match Transaction to Invoices,Tranzacționați tranzacția la facturi,
-Create New Payment/Journal Entry,Creați o nouă plată / intrare în jurnal,
-Submit/Reconcile Payments,Trimiteți / Recondiționați plățile,
-Matching Invoices,Facturi de potrivire,
-Payment Invoice Items,Elemente de factură de plată,
-Reconciled Transactions,Tranzacții Reconciliate,
-Bank Statement Transaction Invoice Item,Tranzacție de poziție bancară,
-Payment Description,Descrierea plății,
-Invoice Date,Data facturii,
-invoice,factura fiscala,
-Bank Statement Transaction Payment Item,Tranzacție de plată a tranzacției,
-outstanding_amount,suma restanta,
-Payment Reference,Referință de plată,
-Bank Statement Transaction Settings Item,Element pentru setările tranzacției din contul bancar,
-Bank Data,Date bancare,
-Mapped Data Type,Mapat tipul de date,
-Mapped Data,Date Cartografiate,
-Bank Transaction,Tranzacție bancară,
-ACC-BTN-.YYYY.-,ACC-BTN-.YYYY.-,
-Transaction ID,ID-ul de tranzacție,
-Unallocated Amount,Suma nealocată,
-Field in Bank Transaction,Câmp în tranzacția bancară,
-Column in Bank File,Coloana în fișierul bancar,
-Bank Transaction Payments,Plăți de tranzacții bancare,
-Control Action,Acțiune de control,
-Applicable on Material Request,Aplicabil la solicitarea materialului,
-Action if Annual Budget Exceeded on MR,Acțiune în cazul depășirii bugetului anual pe MR,
-Warn,Avertiza,
-Ignore,Ignora,
-Action if Accumulated Monthly Budget Exceeded on MR,Acțiune dacă bugetul lunar acumulat este depășit cu MR,
-Applicable on Purchase Order,Aplicabil pe comanda de aprovizionare,
-Action if Annual Budget Exceeded on PO,Acțiune în cazul în care bugetul anual depășește PO,
-Action if Accumulated Monthly Budget Exceeded on PO,Acțiune în cazul în care bugetul lunar acumulat este depășit cu PO,
-Applicable on booking actual expenses,Se aplică la rezervarea cheltuielilor reale,
-Action if Annual Budget Exceeded on Actual,Acțiune în cazul în care bugetul anual depășește suma actuală,
-Action if Accumulated Monthly Budget Exceeded on Actual,Acțiune în cazul în care bugetul lunar acumulat depășește valoarea reală,
-Budget Accounts,Conturile bugetare,
-Budget Account,Contul bugetar,
-Budget Amount,Buget Sumă,
-C-Form,Formular-C,
-ACC-CF-.YYYY.-,ACC-CF-.YYYY.-,
-C-Form No,Nr. formular-C,
-Received Date,Data primit,
-Quarter,Trimestru,
-I,eu,
-II,II,
-III,III,
-IV,IV,
-C-Form Invoice Detail,Detaliu factură formular-C,
-Invoice No,Nr Factura,
-Cash Flow Mapper,Cash Flow Mapper,
-Section Name,Numele secțiunii,
-Section Header,Secțiunea Header,
-Section Leader,Liderul secțiunii,
-e.g Adjustments for:,de ex. ajustări pentru:,
-Section Subtotal,Secțiunea Subtotal,
-Section Footer,Secțiunea Footer,
-Position,Poziţie,
-Cash Flow Mapping,Fluxul de numerar,
-Select Maximum Of 1,Selectați maxim de 1,
-Is Finance Cost,Este costul de finanțare,
-Is Working Capital,Este capitalul de lucru,
-Is Finance Cost Adjustment,Este ajustarea costurilor financiare,
-Is Income Tax Liability,Răspunderea pentru impozitul pe venit,
-Is Income Tax Expense,Cheltuielile cu impozitul pe venit,
-Cash Flow Mapping Accounts,Conturi de cartografiere a fluxurilor de numerar,
-account,Cont,
-Cash Flow Mapping Template,Formatul de cartografiere a fluxului de numerar,
-Cash Flow Mapping Template Details,Detaliile șablonului pentru fluxul de numerar,
-POS-CLO-,POS-CLO-,
-Custody,Custodie,
-Net Amount,Cantitate netă,
-Cashier Closing Payments,Plățile de închidere a caselor,
-Chart of Accounts Importer,Importatorul planului de conturi,
-Import Chart of Accounts from a csv file,Importați Graficul de conturi dintr-un fișier csv,
-Attach custom Chart of Accounts file,Atașați fișierul personalizat al graficului conturilor,
-Chart Preview,Previzualizare grafic,
-Chart Tree,Arbore grafic,
-Cheque Print Template,Format Imprimare Cec,
-Has Print Format,Are Format imprimare,
-Primary Settings,Setări primare,
-Cheque Size,Dimensiune  Cec,
-Regular,Regulat,
-Starting position from top edge,Poziția de la muchia superioară de pornire,
-Cheque Width,Lățime Cec,
-Cheque Height,Cheque Inaltime,
-Scanned Cheque,scanate cecului,
-Is Account Payable,Este cont de plati,
-Distance from top edge,Distanța de la marginea de sus,
-Distance from left edge,Distanța de la marginea din stânga,
-Message to show,Mesaj pentru a arăta,
-Date Settings,Setări Dată,
-Starting location from left edge,Punctul de plecare de la marginea din stânga,
-Payer Settings,Setări plătitorilor,
-Width of amount in word,Lățimea de cuvânt în sumă,
-Line spacing for amount in words,distanța dintre rânduri pentru suma în cuvinte,
-Amount In Figure,Suma în Figura,
-Signatory Position,Poziție semnatar,
-Closed Document,Document închis,
-Track separate Income and Expense for product verticals or divisions.,Urmăriți Venituri separat și cheltuieli verticale produse sau divizii.,
-Cost Center Name,Nume Centrul de Cost,
-Parent Cost Center,Părinte Cost Center,
-lft,LFT,
-rgt,RGT,
-Coupon Code,Codul promoțional,
-Coupon Name,Numele cuponului,
-"e.g. ""Summer Holiday 2019 Offer 20""",de ex. „Oferta de vacanță de vară 2019 20”,
-Coupon Type,Tip cupon,
-Promotional,promoționale,
-Gift Card,Card cadou,
-unique e.g. SAVE20  To be used to get discount,"unic, de exemplu, SAVE20 Pentru a fi utilizat pentru a obține reducere",
-Validity and Usage,Valabilitate și utilizare,
-Valid From,Valabil din,
-Valid Upto,Valid pana la,
-Maximum Use,Utilizare maximă,
-Used,Folosit,
-Coupon Description,Descrierea cuponului,
-Discounted Invoice,Factură redusă,
-Debit to,Debit la,
-Exchange Rate Revaluation,Reevaluarea cursului de schimb,
-Get Entries,Obțineți intrări,
-Exchange Rate Revaluation Account,Contul de reevaluare a cursului de schimb,
-Total Gain/Loss,Total câștig / pierdere,
-Balance In Account Currency,Soldul în moneda contului,
-Current Exchange Rate,Cursul de schimb curent,
-Balance In Base Currency,Soldul în moneda de bază,
-New Exchange Rate,Noul curs de schimb valutar,
-New Balance In Base Currency,Noul echilibru în moneda de bază,
-Gain/Loss,Gain / Pierdere,
-**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,**Anul fiscal** reprezintă un an financiar. Toate intrările contabile și alte tranzacții majore sunt monitorizate comparativ cu ** Anul fiscal **.,
-Year Name,An Denumire,
-"For e.g. 2012, 2012-13","De exemplu, 2012, 2012-13",
-Year Start Date,An Data începerii,
-Year End Date,Anul Data de încheiere,
-Companies,Companii,
-Auto Created,Crearea automată,
-Stock User,Stoc de utilizare,
-Fiscal Year Company,Anul fiscal companie,
-Debit Amount,Sumă Debit,
-Credit Amount,Suma de credit,
-Debit Amount in Account Currency,Sumă Debit în Monedă Cont,
-Credit Amount in Account Currency,Suma de credit în cont valutar,
-Voucher Detail No,Detaliu voucher Nu,
-Is Opening,Se deschide,
-Is Advance,Este Advance,
-To Rename,Pentru a redenumi,
-GST Account,Contul GST,
-CGST Account,Contul CGST,
-SGST Account,Contul SGST,
-IGST Account,Cont IGST,
-CESS Account,Cont CESS,
-Loan Start Date,Data de început a împrumutului,
-Loan Period (Days),Perioada de împrumut (zile),
-Loan End Date,Data de încheiere a împrumutului,
-Bank Charges,Taxe bancare,
-Short Term Loan Account,Cont de împrumut pe termen scurt,
-Bank Charges Account,Cont de taxe bancare,
-Accounts Receivable Credit Account,Conturi de credit de primit,
-Accounts Receivable Discounted Account,Conturi de primit cu reducere,
-Accounts Receivable Unpaid Account,Conturi de primit un cont neplătit,
-Item Tax Template,Șablon fiscal de articol,
-Tax Rates,Taxe de impozitare,
-Item Tax Template Detail,Detaliu de șablon fiscal,
-Entry Type,Tipul de intrare,
-Inter Company Journal Entry,Intrarea în Jurnalul Inter companiei,
-Bank Entry,Intrare bancară,
-Cash Entry,Cash intrare,
-Credit Card Entry,Card de credit intrare,
-Contra Entry,Contra intrare,
-Excise Entry,Intrare accize,
-Write Off Entry,Amortizare intrare,
-Opening Entry,Deschiderea de intrare,
-ACC-JV-.YYYY.-,ACC-JV-.YYYY.-,
-Accounting Entries,Înregistrări contabile,
-Total Debit,Total debit,
-Total Credit,Total credit,
-Difference (Dr - Cr),Diferența (Dr - Cr),
-Make Difference Entry,Realizeaza Intrare de Diferenta,
-Total Amount Currency,Suma totală Moneda,
-Total Amount in Words,Suma totală în cuvinte,
-Remark,Remarcă,
-Paid Loan,Imprumut platit,
-Inter Company Journal Entry Reference,Întreprindere de referință pentru intrarea în jurnal,
-Write Off Based On,Scrie Off bazat pe,
-Get Outstanding Invoices,Obtine Facturi Neachitate,
-Write Off Amount,Anulați suma,
-Printing Settings,Setări de imprimare,
-Pay To / Recd From,Pentru a plăti / Recd de la,
-Payment Order,Ordin de plată,
-Subscription Section,Secțiunea de abonamente,
-Journal Entry Account,Jurnal de cont intrare,
-Account Balance,Soldul contului,
-Party Balance,Balanța Party,
-Accounting Dimensions,Dimensiuni contabile,
-If Income or Expense,In cazul Veniturilor sau Cheltuielilor,
-Exchange Rate,Rata de schimb,
-Debit in Company Currency,Debit în Monedă Companie,
-Credit in Company Currency,Credit în companie valutar,
-Payroll Entry,Salarizare intrare,
-Employee Advance,Angajat Advance,
-Reference Due Date,Data de referință pentru referință,
-Loyalty Program Tier,Program de loialitate,
-Redeem Against,Răscumpărați împotriva,
-Expiry Date,Data expirării,
-Loyalty Point Entry Redemption,Punctul de răscumpărare a punctelor de loialitate,
-Redemption Date,Data de răscumpărare,
-Redeemed Points,Răscumpărate Puncte,
-Loyalty Program Name,Nume program de loialitate,
-Loyalty Program Type,Tip de program de loialitate,
-Single Tier Program,Program unic de nivel,
-Multiple Tier Program,Program multiplu,
-Customer Territory,Teritoriul clientului,
-Auto Opt In (For all customers),Oprire automată (pentru toți clienții),
-Collection Tier,Colecția Tier,
-Collection Rules,Regulile de colectare,
-Redemption,Răscumpărare,
-Conversion Factor,Factor de conversie,
-1 Loyalty Points = How much base currency?,1 Puncte de loialitate = Cât de multă monedă de bază?,
-Expiry Duration (in days),Termenul de expirare (în zile),
-Help Section,Secțiunea Ajutor,
-Loyalty Program Help,Programul de ajutor pentru loialitate,
-Loyalty Program Collection,Colecția de programe de loialitate,
-Tier Name,Denumirea nivelului,
-Minimum Total Spent,Suma totală cheltuită,
-Collection Factor (=1 LP),Factor de colectare (= 1 LP),
-For how much spent = 1 Loyalty Point,Pentru cât de mult a fost cheltuit = 1 punct de loialitate,
-Mode of Payment Account,Modul de cont de plăți,
-Default Account,Cont Implicit,
-Default account will be automatically updated in POS Invoice when this mode is selected.,Contul implicit va fi actualizat automat în factură POS când este selectat acest mod.,
-**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,** Lunar Distribuție ** vă ajută să distribuie bugetul / Target peste luni dacă aveți sezonier în afacerea dumneavoastră.,
-Distribution Name,Denumire Distribuție,
-Name of the Monthly Distribution,Numele de Distributie lunar,
-Monthly Distribution Percentages,Procente de distribuție lunare,
-Monthly Distribution Percentage,Lunar Procentaj Distribuție,
-Percentage Allocation,Alocarea procent,
-Create Missing Party,Creați Parte Lipsă,
-Create missing customer or supplier.,Creați client sau furnizor lipsă.,
-Opening Invoice Creation Tool Item,Deschiderea elementului instrumentului de creare a facturilor,
-Temporary Opening Account,Contul de deschidere temporar,
-Party Account,Party Account,
-Type of Payment,Tipul de plată,
-ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-,
-Receive,Primește,
-Internal Transfer,Transfer intern,
-Payment Order Status,Starea comenzii de plată,
-Payment Ordered,Plata a fost comandată,
-Payment From / To,Plata De la / la,
-Company Bank Account,Cont bancar al companiei,
-Party Bank Account,Cont bancar de partid,
-Account Paid From,Contul plătit De la,
-Account Paid To,Contul Plătite,
-Paid Amount (Company Currency),Plătit Suma (Compania de valuta),
-Received Amount,Sumă Primită,
-Received Amount (Company Currency),Suma primită (Moneda Companiei),
-Get Outstanding Invoice,Obțineți o factură excepțională,
-Payment References,Referințe de plată,
-Writeoff,Achita,
-Total Allocated Amount,Suma totală alocată,
-Total Allocated Amount (Company Currency),Suma totală alocată (Companie Moneda),
-Set Exchange Gain / Loss,Set Exchange Gain / Pierdere,
-Difference Amount (Company Currency),Diferența Sumă (Companie Moneda),
-Write Off Difference Amount,Diferență Sumă Piertdute,
-Deductions or Loss,Deduceri sau Pierderi,
-Payment Deductions or Loss,Deducerile de plată sau pierdere,
-Cheque/Reference Date,Cec/Dată de Referință,
-Payment Entry Deduction,Plată Deducerea intrare,
-Payment Entry Reference,Plată intrare de referință,
-Allocated,Alocat,
-Payment Gateway Account,Plata cont Gateway,
-Payment Account,Cont de plăți,
-Default Payment Request Message,Implicit solicita plata mesaj,
-PMO-,PMO-,
-Payment Order Type,Tipul ordinului de plată,
-Payment Order Reference,Instrucțiuni de plată,
-Bank Account Details,Detaliile contului bancar,
-Payment Reconciliation,Reconcilierea plată,
-Receivable / Payable Account,De încasat de cont / de plătit,
-Bank / Cash Account,Cont bancă / numerar,
-From Invoice Date,De la data facturii,
-To Invoice Date,Pentru a facturii Data,
-Minimum Invoice Amount,Factură cantitate minimă,
-Maximum Invoice Amount,Suma maxima Factură,
-System will fetch all the entries if limit value is zero.,Sistemul va prelua toate intrările dacă valoarea limită este zero.,
-Get Unreconciled Entries,Ia nereconciliate Entries,
-Unreconciled Payment Details,Nereconciliate Detalii de plată,
-Invoice/Journal Entry Details,Factura / Jurnalul Detalii intrari,
-Payment Reconciliation Invoice,Reconcilierea plata facturii,
-Invoice Number,Numar factura,
-Payment Reconciliation Payment,Reconciliere de plata,
-Reference Row,rândul de referință,
-Allocated amount,Suma alocată,
-Payment Request Type,Tip de solicitare de plată,
-Outward,Exterior,
-Inward,interior,
-ACC-PRQ-.YYYY.-,ACC-PRQ-.YYYY.-,
-Transaction Details,Detalii tranzacție,
-Amount in customer's currency,Suma în moneda clientului,
-Is a Subscription,Este un abonament,
-Transaction Currency,Operațiuni valutare,
-Subscription Plans,Planuri de abonament,
-SWIFT Number,Număr rapid,
-Recipient Message And Payment Details,Mesaj destinatar și Detalii de plată,
-Make Sales Invoice,Faceți Factură de Vânzare,
-Mute Email,Mute Email,
-payment_url,payment_url,
-Payment Gateway Details,Plata Gateway Detalii,
-Payment Schedule,Planul de plăți,
-Invoice Portion,Fracțiunea de facturi,
-Payment Amount,Plata Suma,
-Payment Term Name,Numele termenului de plată,
-Due Date Based On,Data de bază bazată pe,
-Day(s) after invoice date,Ziua (zilele) după data facturii,
-Day(s) after the end of the invoice month,Ziua (zilele) de la sfârșitul lunii facturii,
-Month(s) after the end of the invoice month,Luna (luni) după sfârșitul lunii facturii,
-Credit Days,Zile de Credit,
-Credit Months,Lunile de credit,
-Allocate Payment Based On Payment Terms,Alocați plata în funcție de condițiile de plată,
-"If this checkbox is checked, paid amount will be splitted and allocated as per the amounts in payment schedule against each payment term","Dacă această casetă de selectare este bifată, suma plătită va fi împărțită și alocată conform sumelor din programul de plată pentru fiecare termen de plată",
-Payment Terms Template Detail,Plata detaliilor privind termenii de plată,
-Closing Fiscal Year,Închiderea Anului Fiscal,
-Closing Account Head,Închidere Cont Principal,
-"The account head under Liability or Equity, in which Profit/Loss will be booked","Capul de cont sub răspunderea sau a capitalului propriu, în care Profit / Pierdere vor fi rezervate",
-POS Customer Group,Grup Clienți POS,
-POS Field,Câmpul POS,
-POS Item Group,POS Articol Grupa,
-Company Address,Adresă Companie,
-Update Stock,Actualizare stock,
-Ignore Pricing Rule,Ignora Regula Preturi,
-Applicable for Users,Aplicabil pentru utilizatori,
-Sales Invoice Payment,Vânzări factură de plată,
-Item Groups,Grupuri articol,
-Only show Items from these Item Groups,Afișați numai articole din aceste grupuri de articole,
-Customer Groups,Grupuri de clienți,
-Only show Customer of these Customer Groups,Afișați numai Clientul acestor grupuri de clienți,
-Write Off Account,Scrie Off cont,
-Write Off Cost Center,Scrie Off cost Center,
-Account for Change Amount,Contul pentru Schimbare Sumă,
-Taxes and Charges,Impozite și Taxe,
-Apply Discount On,Aplicați Discount pentru,
-POS Profile User,Utilizator de profil POS,
-Apply On,Se aplică pe,
-Price or Product Discount,Preț sau reducere produs,
-Apply Rule On Item Code,Aplicați regula pe codul articolului,
-Apply Rule On Item Group,Aplicați regula pe grupul de articole,
-Apply Rule On Brand,Aplicați regula pe marcă,
-Mixed Conditions,Condiții mixte,
-Conditions will be applied on all the selected items combined. ,Condițiile se vor aplica pe toate elementele selectate combinate.,
-Is Cumulative,Este cumulativ,
-Coupon Code Based,Bazat pe codul cuponului,
-Discount on Other Item,Reducere la alt articol,
-Apply Rule On Other,Aplicați regula pe alte,
-Party Information,Informații despre petreceri,
-Quantity and Amount,Cantitate și sumă,
-Min Qty,Min Cantitate,
-Max Qty,Max Cantitate,
-Min Amt,Amt min,
-Max Amt,Max Amt,
-Period Settings,Setări perioade,
-Margin,Margin,
-Margin Type,Tipul de marjă,
-Margin Rate or Amount,Rata de marjă sau Sumă,
-Price Discount Scheme,Schema de reducere a prețurilor,
-Rate or Discount,Tarif sau Discount,
-Discount Percentage,Procentul de Reducere,
-Discount Amount,Reducere Suma,
-For Price List,Pentru Lista de Preturi,
-Product Discount Scheme,Schema de reducere a produsului,
-Same Item,Același articol,
-Free Item,Articol gratuit,
-Threshold for Suggestion,Prag pentru sugestie,
-System will notify to increase or decrease quantity or amount ,Sistemul va notifica să crească sau să scadă cantitatea sau cantitatea,
-"Higher the number, higher the priority","Este mai mare numărul, mai mare prioritate",
-Apply Multiple Pricing Rules,Aplicați mai multe reguli privind prețurile,
-Apply Discount on Rate,Aplicați reducere la tarif,
-Validate Applied Rule,Validați regula aplicată,
-Rule Description,Descrierea regulii,
-Pricing Rule Help,Regula de stabilire a prețurilor de ajutor,
-Promotional Scheme Id,Codul promoțional ID,
-Promotional Scheme,Schema promoțională,
-Pricing Rule Brand,Marca de regulă a prețurilor,
-Pricing Rule Detail,Detaliu privind regula prețurilor,
-Child Docname,Numele documentului pentru copii,
-Rule Applied,Regula aplicată,
-Pricing Rule Item Code,Regula prețurilor Cod articol,
-Pricing Rule Item Group,Grupul de articole din regula prețurilor,
-Price Discount Slabs,Placi cu reducere de preț,
-Promotional Scheme Price Discount,Schema promoțională Reducere de preț,
-Product Discount Slabs,Placi cu reducere de produse,
-Promotional Scheme Product Discount,Schema promoțională Reducere de produs,
-Min Amount,Suma minima,
-Max Amount,Suma maximă,
-Discount Type,Tipul reducerii,
-ACC-PINV-.YYYY.-,ACC-PINV-.YYYY.-,
-Tax Withholding Category,Categoria de reținere fiscală,
-Edit Posting Date and Time,Editare postare Data și ora,
-Is Paid,Este platit,
-Is Return (Debit Note),Este Return (Nota de debit),
-Apply Tax Withholding Amount,Aplicați suma de reținere fiscală,
-Accounting Dimensions ,Dimensiuni contabile,
-Supplier Invoice Details,Furnizor Detalii factură,
-Supplier Invoice Date,Furnizor Data facturii,
-Return Against Purchase Invoice,Reveni Împotriva cumparare factură,
-Select Supplier Address,Selectați Furnizor Adresă,
-Contact Person,Persoană de contact,
-Select Shipping Address,Selectați adresa de expediere,
-Currency and Price List,Valută și lista de prețuri,
-Price List Currency,Lista de pret Valuta,
-Price List Exchange Rate,Lista de schimb valutar,
-Set Accepted Warehouse,Set depozit acceptat,
-Rejected Warehouse,Depozit Respins,
-Warehouse where you are maintaining stock of rejected items,Depozit în cazul în care se menține stocul de articole respinse,
-Raw Materials Supplied,Materii prime furnizate,
-Supplier Warehouse,Furnizor Warehouse,
-Pricing Rules,Reguli privind prețurile,
-Supplied Items,Articole furnizate,
-Total (Company Currency),Total (Company valutar),
-Net Total (Company Currency),Net total (Compania de valuta),
-Total Net Weight,Greutatea totală netă,
-Shipping Rule,Regula de transport maritim,
-Purchase Taxes and Charges Template,Achiziționa impozite și taxe Template,
-Purchase Taxes and Charges,Taxele de cumpărare și Taxe,
-Tax Breakup,Descărcarea de impozite,
-Taxes and Charges Calculation,Impozite și Taxe Calcul,
-Taxes and Charges Added (Company Currency),Impozite și Taxe adăugate (Compania de valuta),
-Taxes and Charges Deducted (Company Currency),Impozite și taxe deduse (Compania de valuta),
-Total Taxes and Charges (Company Currency),Total Impozite si Taxe (Compania valutar),
-Taxes and Charges Added,Impozite și Taxe Added,
-Taxes and Charges Deducted,Impozite și Taxe dedus,
-Total Taxes and Charges,Total Impozite și Taxe,
-Additional Discount,Discount suplimentar,
-Apply Additional Discount On,Aplicați Discount suplimentare La,
-Additional Discount Amount (Company Currency),Discount suplimentar Suma (companie de valuta),
-Additional Discount Percentage,Procent de reducere suplimentară,
-Additional Discount Amount,Suma de reducere suplimentară,
-Grand Total (Company Currency),Total general (Valuta Companie),
-Rounding Adjustment (Company Currency),Rotunjire ajustare (moneda companiei),
-Rounded Total (Company Currency),Rotunjite total (Compania de valuta),
-In Words (Company Currency),În cuvinte (Compania valutar),
-Rounding Adjustment,Ajustare Rotunjire,
-In Words,În cuvinte,
-Total Advance,Total de Advance,
-Disable Rounded Total,Dezactivati Totalul Rotunjit,
-Cash/Bank Account,Numerar/Cont Bancar,
-Write Off Amount (Company Currency),Scrie Off Suma (Compania de valuta),
-Set Advances and Allocate (FIFO),Setați avansuri și alocați (FIFO),
-Get Advances Paid,Obtine Avansurile Achitate,
-Advances,Avansuri,
-Terms,Termeni,
-Terms and Conditions1,Termeni și Conditions1,
-Group same items,Același grup de elemente,
-Print Language,Limba de imprimare,
-"Once set, this invoice will be on hold till the set date","Odată stabilită, această factură va fi reținută până la data stabilită",
-Credit To,De Creditat catre,
-Party Account Currency,Partidul cont valutar,
-Against Expense Account,Comparativ contului de cheltuieli,
-Inter Company Invoice Reference,Interfața de referință pentru interfața companiei,
-Is Internal Supplier,Este furnizor intern,
-Start date of current invoice's period,Data perioadei de factura de curent începem,
-End date of current invoice's period,Data de încheiere a perioadei facturii curente,
-Update Auto Repeat Reference,Actualizați referința de repetare automată,
-Purchase Invoice Advance,Factura de cumpărare în avans,
-Purchase Invoice Item,Factura de cumpărare Postul,
-Quantity and Rate,Cantitatea și rata,
-Received Qty,Cantitate primita,
-Accepted Qty,Cantitate acceptată,
-Rejected Qty,Cant. Respinsă,
-UOM Conversion Factor,Factorul de conversie UOM,
-Discount on Price List Rate (%),Reducere la Lista de preturi Rate (%),
-Price List Rate (Company Currency),Lista de prețuri Rate (Compania de valuta),
-Rate ,,
-Rate (Company Currency),Rata de (Compania de valuta),
-Amount (Company Currency),Sumă (monedă companie),
-Is Free Item,Este articol gratuit,
-Net Rate,Rata netă,
-Net Rate (Company Currency),Rata netă (companie de valuta),
-Net Amount (Company Currency),Suma netă (companie de valuta),
-Item Tax Amount Included in Value,Suma impozitului pe articol inclus în valoare,
-Landed Cost Voucher Amount,Costul Landed Voucher Suma,
-Raw Materials Supplied Cost,Costul materiilor prime livrate,
-Accepted Warehouse,Depozit Acceptat,
-Serial No,Nr. serie,
-Rejected Serial No,Respins de ordine,
-Expense Head,Beneficiar Cheltuiala,
-Is Fixed Asset,Este activ fix,
-Asset Location,Locația activelor,
-Deferred Expense,Cheltuieli amânate,
-Deferred Expense Account,Contul de cheltuieli amânate,
-Service Stop Date,Data de începere a serviciului,
-Enable Deferred Expense,Activați cheltuielile amânate,
-Service Start Date,Data de începere a serviciului,
-Service End Date,Data de încheiere a serviciului,
-Allow Zero Valuation Rate,Permiteți ratei de evaluare zero,
-Item Tax Rate,Rata de Impozitare Articol,
-Tax detail table fetched from item master as a string and stored in this field.\nUsed for Taxes and Charges,Taxa detaliu tabel preluat de la maestru articol ca un șir și stocate în acest domeniu.\n Folosit pentru Impozite și Taxe,
-Purchase Order Item,Comandă de aprovizionare Articol,
-Purchase Receipt Detail,Detaliu de primire a achiziției,
-Item Weight Details,Greutate Detalii articol,
-Weight Per Unit,Greutate pe unitate,
-Total Weight,Greutate totală,
-Weight UOM,Greutate UOM,
-Page Break,Page Break,
-Consider Tax or Charge for,Considerare Taxa sau Cost pentru,
-Valuation and Total,Evaluare și Total,
-Valuation,Evaluare,
-Add or Deduct,Adăugaţi sau deduceţi,
-Deduct,Deduce,
-On Previous Row Amount,La rândul precedent Suma,
-On Previous Row Total,Inapoi la rândul Total,
-On Item Quantity,Pe cantitatea articolului,
-Reference Row #,Reference Row #,
-Is this Tax included in Basic Rate?,Este acest fiscală inclusă în rata de bază?,
-"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","In cazul in care se bifeaza, suma taxelor va fi considerată ca fiind deja inclusa în Rata de Imprimare / Suma de Imprimare",
-Account Head,Titularul Contului,
-Tax Amount After Discount Amount,Suma taxa După Discount Suma,
-Item Wise Tax Detail ,Articolul Detaliu fiscal înțelept,
-"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.\n10. Add or Deduct: Whether you want to add or deduct the tax.","Șablon de impozitare standard care pot fi aplicate la toate tranzacțiile de cumpărare. Acest model poate conține lista de capete fiscale și, de asemenea, mai multe capete de cheltuieli, cum ar fi ""de transport"", ""asigurare"", ""manipulare"" etc. \n\n #### Notă \n\n Rata de impozitare pe care o definiți aici va fi rata de impozitare standard pentru toate Articole ** **. Dacă există articole ** **, care au preturi diferite, acestea trebuie să fie adăugate în ** Impozitul Postul ** masă în ** ** postul comandantului.\n\n #### Descrierea de coloane \n\n 1. Calcul Tip: \n - Acest lucru poate fi pe ** net total ** (care este suma cuantum de bază).\n - ** La rândul precedent Raport / Suma ** (pentru impozite sau taxe cumulative). Dacă selectați această opțiune, impozitul va fi aplicat ca procent din rândul anterior (în tabelul de impozitare) suma totală sau.\n - ** ** Real (după cum sa menționat).\n 2. Șeful cont: Registrul cont în care acest impozit va fi rezervat \n 3. Cost Center: În cazul în care taxa / taxa este un venit (cum ar fi de transport maritim) sau cheltuieli trebuie să se rezervat împotriva unui centru de cost.\n 4. Descriere: Descriere a taxei (care vor fi tipărite în facturi / citate).\n 5. Notă: Rata de Profit Brut.\n 6. Suma: suma taxei.\n 7. Total: total cumulat la acest punct.\n 8. Introduceți Row: Dacă bazat pe ""Înapoi Row Total"", puteți selecta numărul rând care vor fi luate ca bază pentru acest calcul (implicit este rândul precedent).\n 9. Luați în considerare Brut sau Taxa pentru: În această secțiune puteți specifica dacă taxa / taxa este doar pentru evaluare (nu o parte din total) sau numai pe total (nu adaugă valoare elementul) sau pentru ambele.\n 10. Adăugați sau deduce: Fie că doriți să adăugați sau deduce taxa.",
-Salary Component Account,Contul de salariu Componentă,
-Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Default cont bancar / numerar vor fi actualizate automat în Jurnalul de intrare a salariului când este selectat acest mod.,
-ACC-SINV-.YYYY.-,ACC-SINV-.YYYY.-,
-Include Payment (POS),Include de plată (POS),
-Offline POS Name,Offline Numele POS,
-Is Return (Credit Note),Este retur (nota de credit),
-Return Against Sales Invoice,Reveni Împotriva Vânzări factură,
-Update Billed Amount in Sales Order,Actualizați suma facturată în comandă de vânzări,
-Customer PO Details,Detalii PO pentru clienți,
-Customer's Purchase Order,Comandă clientului,
-Customer's Purchase Order Date,Data Comanda de Aprovizionare Client,
-Customer Address,Adresă Client,
-Shipping Address Name,Transport Adresa Nume,
-Company Address Name,Nume Companie,
-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 customer's base currency,Rata la care lista de prețuri moneda este convertit în valuta de bază a clientului,
-Set Source Warehouse,Set sursă depozit,
-Packing List,Lista de ambalare,
-Packed Items,Articole pachet,
-Product Bundle Help,Produs Bundle Ajutor,
-Time Sheet List,Listă de timp Sheet,
-Time Sheets,Foi de timp,
-Total Billing Amount,Suma totală de facturare,
-Sales Taxes and Charges Template,Impozite vânzări și șabloane Taxe,
-Sales Taxes and Charges,Taxele de vânzări și Taxe,
-Loyalty Points Redemption,Răscumpărarea punctelor de loialitate,
-Redeem Loyalty Points,Răscumpărați punctele de loialitate,
-Redemption Account,Cont de Răscumpărare,
-Redemption Cost Center,Centrul de cost de răscumpărare,
-In Words will be visible once you save the Sales Invoice.,În cuvinte va fi vizibil după salvarea facturii.,
-Allocate Advances Automatically (FIFO),Alocați avansuri automat (FIFO),
-Get Advances Received,Obtine Avansurile Primite,
-Base Change Amount (Company Currency),De schimbare a bazei Suma (Companie Moneda),
-Write Off Outstanding Amount,Scrie Off remarcabile Suma,
-Terms and Conditions Details,Termeni și condiții Detalii,
-Is Internal Customer,Este client intern,
-Is Discounted,Este redus,
-Unpaid and Discounted,Neplătit și redus,
-Overdue and Discounted,Întârziat și redus,
-Accounting Details,Detalii Contabilitate,
-Debit To,Debit Pentru,
-Is Opening Entry,Deschiderea este de intrare,
-C-Form Applicable,Formular-C aplicabil,
-Commission Rate (%),Rata de Comision (%),
-Sales Team1,Vânzări TEAM1,
-Against Income Account,Comparativ contului de venit,
-Sales Invoice Advance,Factura Vanzare Advance,
-Advance amount,Sumă în avans,
-Sales Invoice Item,Factură de vânzări Postul,
-Customer's Item Code,Cod Articol Client,
-Brand Name,Denumire marcă,
-Qty as per Stock UOM,Cantitate conform Stock UOM,
-Discount and Margin,Reducere și marja de profit,
-Rate With Margin,Rate cu marjă,
-Discount (%) on Price List Rate with Margin,Reducere (%) la rata de listă cu marjă,
-Rate With Margin (Company Currency),Rata cu marjă (moneda companiei),
-Delivered By Supplier,Livrate de Furnizor,
-Deferred Revenue,Venituri amânate,
-Deferred Revenue Account,Contul de venituri amânate,
-Enable Deferred Revenue,Activați venitul amânat,
-Stock Details,Stoc Detalii,
-Customer Warehouse (Optional),Depozit de client (opțional),
-Available Batch Qty at Warehouse,Cantitate lot disponibilă în depozit,
-Available Qty at Warehouse,Cantitate disponibilă în depozit,
-Delivery Note Item,Articol de nota de Livrare,
-Base Amount (Company Currency),Suma de bază (Companie Moneda),
-Sales Invoice Timesheet,Vânzări factură Pontaj,
-Time Sheet,Fișa de timp,
-Billing Hours,Ore de facturare,
-Timesheet Detail,Detalii pontaj,
-Tax Amount After Discount Amount (Company Currency),Suma impozitului pe urma Discount Suma (companie de valuta),
-Item Wise Tax Detail,Detaliu Taxa Avizata Articol,
-Parenttype,ParentType,
-"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","Șablon de impozitare standard, care pot fi aplicate la toate tranzacțiile de vânzare. Acest model poate conține lista de capete fiscale și, de asemenea, mai multe capete de cheltuieli / venituri, cum ar fi ""de transport"", ""asigurare"", ""manipulare"" etc. \n\n #### Notă \n\n vă Rata de impozitare defini aici va fi cota de impozitare standard pentru toate Articole ** **. Dacă există articole ** **, care au preturi diferite, acestea trebuie să fie adăugate în ** Impozitul Postul ** masă în ** ** postul comandantului.\n\n #### Descrierea de coloane \n\n 1. Calcul Tip: \n - Acest lucru poate fi pe ** net total ** (care este suma cuantum de bază).\n - ** La rândul precedent Raport / Suma ** (pentru impozite sau taxe cumulative). Dacă selectați această opțiune, impozitul va fi aplicat ca procent din rândul anterior (în tabelul de impozitare) suma totală sau.\n - ** ** Real (după cum sa menționat).\n 2. Șeful cont: Registrul cont în care acest impozit va fi rezervat \n 3. Cost Center: În cazul în care taxa / taxa este un venit (cum ar fi de transport maritim) sau cheltuieli trebuie să se rezervat împotriva unui centru de cost.\n 4. Descriere: Descriere a taxei (care vor fi tipărite în facturi / citate).\n 5. Notă: Rata de Profit Brut.\n 6. Suma: suma taxei.\n 7. Total: total cumulat la acest punct.\n 8. Introduceți Row: Dacă bazat pe ""Înapoi Row Total"", puteți selecta numărul rând care vor fi luate ca bază pentru acest calcul (implicit este rândul precedent).\n 9. Este Brut inclus în rata de bază ?: Dacă verifica acest lucru, înseamnă că acest impozit nu va fi arătată tabelul de mai jos articol, dar vor fi incluse în rata de bază din tabelul punctul principal. Acest lucru este util în cazul în care doriți dau un preț plat (cu toate taxele incluse) preț pentru clienți.",
-* Will be calculated in the transaction.,* Va fi calculat în cadrul tranzacției.,
-From No,De la nr,
-To No,Pentru a Nu,
-Is Company,Este compania,
-Current State,Starea curenta,
-Purchased,Cumparate,
-From Shareholder,De la acționar,
-From Folio No,Din Folio nr,
-To Shareholder,Pentru acționar,
-To Folio No,Pentru Folio nr,
-Equity/Liability Account,Contul de capitaluri proprii,
-Asset Account,Cont de active,
-(including),(inclusiv),
-ACC-SH-.YYYY.-,ACC-SH-.YYYY.-,
-Folio no.,Folio nr.,
-Address and Contacts,Adresa și Contacte,
-Contact List,Listă de contacte,
-Hidden list maintaining the list of contacts linked to Shareholder,Lista ascunsă menținând lista contactelor legate de acționar,
-Specify conditions to calculate shipping amount,Precizați condițiile de calcul cantitate de transport maritim,
-Shipping Rule Label,Regula de transport maritim Label,
-example: Next Day Shipping,exemplu: Next Day Shipping,
-Shipping Rule Type,Tipul regulii de transport,
-Shipping Account,Contul de transport maritim,
-Calculate Based On,Calculaţi pe baza,
-Fixed,Fix,
-Net Weight,Greutate netă,
-Shipping Amount,Suma de transport maritim,
-Shipping Rule Conditions,Condiții Regula de transport maritim,
-Restrict to Countries,Limitează la Țări,
-Valid for Countries,Valabil pentru țările,
-Shipping Rule Condition,Regula Condiții presetate,
-A condition for a Shipping Rule,O condiție pentru o normă de transport,
-From Value,Din Valoare,
-To Value,La valoarea,
-Shipping Rule Country,Regula de transport maritim Tara,
-Subscription Period,Perioada de abonament,
-Subscription Start Date,Data de începere a abonamentului,
-Cancelation Date,Data Anulării,
-Trial Period Start Date,Perioada de începere a perioadei de încercare,
-Trial Period End Date,Data de încheiere a perioadei de încercare,
-Current Invoice Start Date,Data de începere a facturii actuale,
-Current Invoice End Date,Data de încheiere a facturii actuale,
-Days Until Due,Zile Până la Termen,
-Number of days that the subscriber has to pay invoices generated by this subscription,Numărul de zile în care abonatul trebuie să plătească facturile generate de acest abonament,
-Cancel At End Of Period,Anulați la sfârșitul perioadei,
-Generate Invoice At Beginning Of Period,Generați factura la începutul perioadei,
-Plans,Planuri,
-Discounts,reduceri,
-Additional DIscount Percentage,Procent Discount Suplimentar,
-Additional DIscount Amount,Valoare discount-ului suplimentar,
-Subscription Invoice,Factura de abonament,
-Subscription Plan,Planul de abonament,
-Cost,Cost,
-Billing Interval,Intervalul de facturare,
-Billing Interval Count,Intervalul de facturare,
-"Number of intervals for the interval field e.g if Interval is 'Days' and Billing Interval Count is 3, invoices will be generated every 3 days","Numărul de intervale pentru câmpul intervalului, de exemplu, dacă Intervalul este &quot;Zile&quot; și Numărul de intervale de facturare este de 3, facturile vor fi generate la fiecare 3 zile",
-Payment Plan,Plan de plată,
-Subscription Plan Detail,Detaliile planului de abonament,
-Plan,Plan,
-Subscription Settings,Setările pentru abonament,
-Grace Period,Perioadă de grație,
-Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,Numărul de zile după expirarea datei facturii înainte de a anula abonamentul sau marcarea abonamentului ca neplătit,
-Prorate,Prorate,
-Tax Rule,Regula de impozitare,
-Tax Type,Tipul de impozitare,
-Use for Shopping Cart,Utilizați pentru Cos de cumparaturi,
-Billing City,Oraș de facturare,
-Billing County,Județ facturare,
-Billing State,Situatie facturare,
-Billing Zipcode,Cod poștal de facturare,
-Billing Country,Țara facturării,
-Shipping City,Transport Oraș,
-Shipping County,County transport maritim,
-Shipping State,Stat de transport maritim,
-Shipping Zipcode,Cod poștal de expediere,
-Shipping Country,Transport Tara,
-Tax Withholding Account,Contul de reținere fiscală,
-Tax Withholding Rates,Ratele de reținere fiscală,
-Rates,Tarife,
-Tax Withholding Rate,Rata reținerii fiscale,
-Single Transaction Threshold,Singurul prag de tranzacție,
-Cumulative Transaction Threshold,Valoarea cumulată a tranzacției,
-Agriculture Analysis Criteria,Criterii de analiză a agriculturii,
-Linked Doctype,Legate de Doctype,
-Water Analysis,Analiza apei,
-Soil Analysis,Analiza solului,
-Plant Analysis,Analiza plantelor,
-Fertilizer,Îngrăşământ,
-Soil Texture,Textura solului,
-Weather,Vreme,
-Agriculture Manager,Directorul Agriculturii,
-Agriculture User,Utilizator agricol,
-Agriculture Task,Agricultura,
-Task Name,Sarcina Nume,
-Start Day,Ziua de început,
-End Day,Sfârșitul zilei,
-Holiday Management,Gestionarea concediului,
-Ignore holidays,Ignorați sărbătorile,
-Previous Business Day,Ziua lucrătoare anterioară,
-Next Business Day,Ziua următoare de lucru,
-Urgent,De urgență,
-Crop,A decupa,
-Crop Name,Numele plantei,
-Scientific Name,Nume stiintific,
-"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Puteți defini toate sarcinile care trebuie îndeplinite pentru această recoltă aici. Câmpul de zi este folosit pentru a menționa ziua în care sarcina trebuie efectuată, 1 fiind prima zi, etc.",
-Crop Spacing,Decuparea culturii,
-Crop Spacing UOM,Distanțarea culturii UOM,
-Row Spacing,Spațierea rândului,
-Row Spacing UOM,Rândul de spațiu UOM,
-Perennial,peren,
-Biennial,Bienal,
-Planting UOM,Plantarea UOM,
-Planting Area,Zona de plantare,
-Yield UOM,Randamentul UOM,
-Materials Required,Materiale necesare,
-Produced Items,Articole produse,
-Produce,Legume şi fructe,
-Byproducts,produse secundare,
-Linked Location,Locație conectată,
-A link to all the Locations in which the Crop is growing,O legătură către toate locațiile în care cultura este în creștere,
-This will be day 1 of the crop cycle,Aceasta va fi prima zi a ciclului de cultură,
-ISO 8601 standard,Standardul ISO 8601,
-Cycle Type,Tip ciclu,
-Less than a year,Mai putin de un an,
-The minimum length between each plant in the field for optimum growth,Lungimea minimă dintre fiecare plantă din câmp pentru creștere optimă,
-The minimum distance between rows of plants for optimum growth,Distanța minimă dintre rânduri de plante pentru creștere optimă,
-Detected Diseases,Au detectat bolile,
-List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,"Lista bolilor detectate pe teren. Când este selectată, va adăuga automat o listă de sarcini pentru a face față bolii",
-Detected Disease,Boala detectată,
-LInked Analysis,Analiza analizată,
-Disease,boală,
-Tasks Created,Sarcini create,
-Common Name,Denumire Comună,
-Treatment Task,Sarcina de tratament,
-Treatment Period,Perioada de tratament,
-Fertilizer Name,Denumirea îngrășămintelor,
-Density (if liquid),Densitatea (dacă este lichidă),
-Fertilizer Contents,Conținutul de îngrășăminte,
-Fertilizer Content,Conținut de îngrășăminte,
-Linked Plant Analysis,Analiza plantelor conectate,
-Linked Soil Analysis,Analiza solului conectat,
-Linked Soil Texture,Textură de sol conectată,
-Collection Datetime,Data colecției,
-Laboratory Testing Datetime,Timp de testare a laboratorului,
-Result Datetime,Rezultat Datatime,
-Plant Analysis Criterias,Condiții de analiză a plantelor,
-Plant Analysis Criteria,Criterii de analiză a plantelor,
-Minimum Permissible Value,Valoarea minimă admisă,
-Maximum Permissible Value,Valoarea maximă admisă,
-Ca/K,Ca / K,
-Ca/Mg,Ca / Mg,
-Mg/K,Mg / K,
-(Ca+Mg)/K,(Ca + Mg) / K,
-Ca/(K+Ca+Mg),Ca / (K + Ca + Mg),
-Soil Analysis Criterias,Criterii de analiză a solului,
-Soil Analysis Criteria,Criterii de analiză a solului,
-Soil Type,Tipul de sol,
-Loamy Sand,Nisip argilos,
-Sandy Loam,Sandy Loam,
-Loam,Lut,
-Silt Loam,Silt Loam,
-Sandy Clay Loam,Sandy Clay Loam,
-Clay Loam,Argilos,
-Silty Clay Loam,Silty Clay Loam,
-Sandy Clay,Sandy Clay,
-Silty Clay,Lut de râu,
-Clay Composition (%),Compoziția de lut (%),
-Sand Composition (%),Compoziția nisipului (%),
-Silt Composition (%),Compoziția Silt (%),
-Ternary Plot,Ternar Plot,
-Soil Texture Criteria,Criterii de textură a solului,
-Type of Sample,Tipul de eșantion,
-Container,recipient,
-Origin,Origine,
-Collection Temperature ,Temperatura colecției,
-Storage Temperature,Temperatura de depozitare,
-Appearance,Aspect,
-Person Responsible,Persoană responsabilă,
-Water Analysis Criteria,Criterii de analiză a apei,
-Weather Parameter,Parametrul vremii,
-ACC-ASS-.YYYY.-,ACC-ASS-.YYYY.-,
-Asset Owner,Proprietarul de proprietar,
-Asset Owner Company,Societatea de proprietari de active,
-Custodian,Custode,
-Disposal Date,eliminare Data,
-Journal Entry for Scrap,Intrare Jurnal pentru Deșeuri,
-Available-for-use Date,Data disponibilă pentru utilizare,
-Calculate Depreciation,Calculează Amortizare,
-Allow Monthly Depreciation,Permite amortizarea lunară,
-Number of Depreciations Booked,Numărul de Deprecieri rezervat,
-Finance Books,Cărți de finanțare,
-Straight Line,Linie dreapta,
-Double Declining Balance,Dublu degresive,
-Manual,Manual,
-Value After Depreciation,Valoarea după amortizare,
-Total Number of Depreciations,Număr total de Deprecieri,
-Frequency of Depreciation (Months),Frecventa de amortizare (Luni),
-Next Depreciation Date,Data următoarei amortizări,
-Depreciation Schedule,Program de amortizare,
-Depreciation Schedules,Orarele de amortizare,
-Insurance details,Detalii de asigurare,
-Policy number,Numărul politicii,
-Insurer,Asiguratorul,
-Insured value,Valoarea asigurată,
-Insurance Start Date,Data de începere a asigurării,
-Insurance End Date,Data de încheiere a asigurării,
-Comprehensive Insurance,Asigurare completă,
-Maintenance Required,Mentenanță Necesară,
-Check if Asset requires Preventive Maintenance or Calibration,Verificați dacă activul necesită întreținere preventivă sau calibrare,
-Booked Fixed Asset,Carte imobilizată rezervată,
-Purchase Receipt Amount,Suma chitanței de cumpărare,
-Default Finance Book,Cartea de finanțare implicită,
-Quality Manager,Manager de calitate,
-Asset Category Name,Nume activ Categorie,
-Depreciation Options,Opțiunile de amortizare,
-Enable Capital Work in Progress Accounting,Activați activitatea de capital în contabilitate în curs,
-Finance Book Detail,Detaliile cărții de finanțe,
-Asset Category Account,Cont activ Categorie,
-Fixed Asset Account,Cont activ fix,
-Accumulated Depreciation Account,Cont Amortizarea cumulată,
-Depreciation Expense Account,Contul de amortizare de cheltuieli,
-Capital Work In Progress Account,Activitatea de capital în curs de desfășurare,
-Asset Finance Book,Cartea de finanțare a activelor,
-Written Down Value,Valoarea scrise în jos,
-Expected Value After Useful Life,Valoarea așteptată după viață utilă,
-Rate of Depreciation,Rata de depreciere,
-In Percentage,În procent,
-Maintenance Team,Echipă de Mentenanță,
-Maintenance Manager Name,Nume Manager Mentenanță,
-Maintenance Tasks,Sarcini de Mentenanță,
-Manufacturing User,Producție de utilizare,
-Asset Maintenance Log,Jurnalul de întreținere a activelor,
-ACC-AML-.YYYY.-,ACC-CSB-.YYYY.-,
-Maintenance Type,Tip Mentenanta,
-Maintenance Status,Stare Mentenanta,
-Planned,Planificat,
-Has Certificate ,Are certificat,
-Certificate,Certificat,
-Actions performed,Acțiuni efectuate,
-Asset Maintenance Task,Activitatea de întreținere a activelor,
-Maintenance Task,Activitate Mentenanță,
-Preventive Maintenance,Mentenanță preventivă,
-Calibration,Calibrare,
-2 Yearly,2 Anual,
-Certificate Required,Certificat necesar,
-Assign to Name,Atribuiți la Nume,
-Next Due Date,Data următoare,
-Last Completion Date,Ultima dată de finalizare,
-Asset Maintenance Team,Echipa de întreținere a activelor,
-Maintenance Team Name,Nume Echipă de Mentenanță,
-Maintenance Team Members,Membri Echipă de Mentenanță,
-Purpose,Scopul,
-Stock Manager,Stock Manager,
-Asset Movement Item,Element de mișcare a activelor,
-Source Location,Locația sursei,
-From Employee,Din Angajat,
-Target Location,Locația țintă,
-To Employee,Pentru angajat,
-Asset Repair,Repararea activelor,
-ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-,
-Failure Date,Dată de nerespectare,
-Assign To Name,Alocați nume,
-Repair Status,Stare de reparare,
-Error Description,Descrierea erorii,
-Downtime,downtime,
-Repair Cost,Costul reparațiilor,
-Manufacturing Manager,Manager de Producție,
-Current Asset Value,Valoarea activului curent,
-New Asset Value,Valoare nouă a activelor,
-Make Depreciation Entry,Asigurați-vă Amortizarea Intrare,
-Finance Book Id,Numărul cărții de credit,
-Location Name,Numele locatiei,
-Parent Location,Locația părintească,
-Is Container,Este Container,
-Check if it is a hydroponic unit,Verificați dacă este o unitate hidroponică,
-Location Details,Detalii despre locație,
-Latitude,Latitudine,
-Longitude,Longitudine,
-Area,Zonă,
-Area UOM,Zona UOM,
-Tree Details,copac Detalii,
-Maintenance Team Member,Membru Echipă de Mentenanță,
-Team Member,Membru al echipei,
-Maintenance Role,Rol de Mentenanță,
-Buying Settings,Configurări cumparare,
-Settings for Buying Module,Setări pentru cumparare Modulul,
-Supplier Naming By,Furnizor de denumire prin,
-Default Supplier Group,Grupul prestabilit de furnizori,
-Default Buying Price List,Lista de POrețuri de Cumparare Implicita,
-Backflush Raw Materials of Subcontract Based On,Materiile de bază din substratul bazat pe,
-Material Transferred for Subcontract,Material transferat pentru subcontractare,
-Over Transfer Allowance (%),Indemnizație de transfer peste (%),
-Percentage you are allowed to transfer more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to transfer 110 units.,"Procentaj pe care vi se permite să transferați mai mult în raport cu cantitatea comandată. De exemplu: Dacă ați comandat 100 de unități. iar alocația dvs. este de 10%, atunci vi se permite să transferați 110 unități.",
-PUR-ORD-.YYYY.-,PUR-ORD-.YYYY.-,
-Get Items from Open Material Requests,Obține elemente din materiale Cereri deschide,
-Fetch items based on Default Supplier.,Obțineți articole pe baza furnizorului implicit.,
-Required By,Cerute de,
-Order Confirmation No,Confirmarea nr,
-Order Confirmation Date,Data de confirmare a comenzii,
-Customer Mobile No,Client Mobile Nu,
-Customer Contact Email,Contact Email client,
-Set Target Warehouse,Stabilește Depozitul țintă,
-Sets 'Warehouse' in each row of the Items table.,Setează „Depozit” în fiecare rând al tabelului Elemente.,
-Supply Raw Materials,Aprovizionarea cu materii prime,
-Purchase Order Pricing Rule,Regula de preț a comenzii de achiziție,
-Set Reserve Warehouse,Set Rezerva Depozit,
-In Words will be visible once you save the Purchase Order.,În cuvinte va fi vizibil după ce a salva Ordinul de cumparare.,
-Advance Paid,Avans plătit,
-Tracking,Urmărirea,
-% Billed,% Facurat,
-% Received,% Primit,
-Ref SQ,Ref SQ,
-Inter Company Order Reference,Referință de comandă între companii,
-Supplier Part Number,Furnizor Număr,
-Billed Amt,Suma facturată,
-Warehouse and Reference,Depozit și Referință,
-To be delivered to customer,Pentru a fi livrat clientului,
-Material Request Item,Material Cerere Articol,
-Supplier Quotation Item,Furnizor ofertă Articol,
-Against Blanket Order,Împotriva ordinului pătură,
-Blanket Order,Ordinul de ștergere,
-Blanket Order Rate,Rata de comandă a plicului,
-Returned Qty,Cant. Returnată,
-Purchase Order Item Supplied,Comandă de aprovizionare Articol Livrat,
-BOM Detail No,Detaliu BOM nr.,
-Stock Uom,Stoc UOM,
-Raw Material Item Code,Cod Articol Materie Prima,
-Supplied Qty,Furnizat Cantitate,
-Purchase Receipt Item Supplied,Primirea de cumpărare Articol Livrat,
-Current Stock,Stoc curent,
-PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-,
-For individual supplier,Pentru furnizor individual,
-Link to Material Requests,Link către cereri de materiale,
-Message for Supplier,Mesaj pentru Furnizor,
-Request for Quotation Item,Articol Cerere de Oferta,
-Required Date,Data de livrare ceruta,
-Request for Quotation Supplier,Furnizor Cerere de Ofertă,
-Send Email,Trimiteți-ne email,
-Quote Status,Citat Stare,
-Download PDF,descarcă PDF,
-Supplier of Goods or Services.,Furnizor de bunuri sau servicii.,
-Name and Type,Numele și tipul,
-SUP-.YYYY.-,SUP-.YYYY.-,
-Default Bank Account,Cont Bancar Implicit,
-Is Transporter,Este Transporter,
-Represents Company,Reprezintă Compania,
-Supplier Type,Furnizor Tip,
-Allow Purchase Invoice Creation Without Purchase Order,Permiteți crearea facturii de cumpărare fără comandă de achiziție,
-Allow Purchase Invoice Creation Without Purchase Receipt,Permiteți crearea facturii de cumpărare fără chitanță de cumpărare,
-Warn RFQs,Aflați RFQ-urile,
-Warn POs,Avertizează PO-urile,
-Prevent RFQs,Preveniți RFQ-urile,
-Prevent POs,Preveniți PO-urile,
-Billing Currency,Moneda de facturare,
-Default Payment Terms Template,Șablonul Termenii de plată standard,
-Block Supplier,Furnizorul de blocuri,
-Hold Type,Tineți tip,
-Leave blank if the Supplier is blocked indefinitely,Lăsați necompletat dacă Furnizorul este blocat pe o perioadă nedeterminată,
-Default Payable Accounts,Implicit conturi de plătit,
-Mention if non-standard payable account,Menționați dacă contul de plată non-standard,
-Default Tax Withholding Config,Config,
-Supplier Details,Detalii furnizor,
-Statutory info and other general information about your Supplier,Info statutar și alte informații generale despre dvs. de Furnizor,
-PUR-SQTN-.YYYY.-,PUR-SQTN-.YYYY.-,
-Supplier Address,Furnizor Adresa,
-Link to material requests,Link la cererile de materiale,
-Rounding Adjustment (Company Currency,Rotunjire ajustare (moneda companiei,
-Auto Repeat Section,Se repetă secțiunea Auto,
-Is Subcontracted,Este subcontractată,
-Lead Time in days,Timp Pistă în zile,
-Supplier Score,Scorul furnizorului,
-Indicator Color,Indicator Culoare,
-Evaluation Period,Perioada de evaluare,
-Per Week,Pe saptamana,
-Per Month,Pe luna,
-Per Year,Pe an,
-Scoring Setup,Punctul de configurare,
-Weighting Function,Funcție de ponderare,
-"Scorecard variables can be used, as well as:\n{total_score} (the total score from that period),\n{period_number} (the number of periods to present day)\n","Variabilele caracterelor pot fi utilizate, precum și: {total_score} (scorul total din acea perioadă), {period_number} (numărul de perioade până în prezent)",
-Scoring Standings,Puncte de scor,
-Criteria Setup,Setarea criteriilor,
-Load All Criteria,Încărcați toate criteriile,
-Scoring Criteria,Criterii de evaluare,
-Scorecard Actions,Caracteristicile Scorecard,
-Warn for new Request for Quotations,Avertizare pentru o nouă solicitare de ofertă,
-Warn for new Purchase Orders,Avertizați pentru comenzi noi de achiziție,
-Notify Supplier,Notificați Furnizor,
-Notify Employee,Notificați angajatul,
-Supplier Scorecard Criteria,Criteriile Scorecard pentru furnizori,
-Criteria Name,Numele de criterii,
-Max Score,Scor maxim,
-Criteria Formula,Criterii Formula,
-Criteria Weight,Criterii Greutate,
-Supplier Scorecard Period,Perioada de evaluare a furnizorului,
-PU-SSP-.YYYY.-,PU-SSP-.YYYY.-,
-Period Score,Scorul perioadei,
-Calculations,Calculele,
-Criteria,criterii,
-Variables,variabile,
-Supplier Scorecard Setup,Setarea Scorecard pentru furnizori,
-Supplier Scorecard Scoring Criteria,Criteriile de evaluare a Scorecard-ului furnizorului,
-Score,Scor,
-Supplier Scorecard Scoring Standing,Scorecard pentru Scorecard furnizor,
-Standing Name,Numele permanent,
-Purple,Violet,
-Yellow,Galben,
-Orange,portocale,
-Min Grade,Gradul minim,
-Max Grade,Max Grad,
-Warn Purchase Orders,Avertizați comenzile de cumpărare,
-Prevent Purchase Orders,Împiedicați comenzile de achiziție,
-Employee ,Angajat,
-Supplier Scorecard Scoring Variable,Scorul variabil al scorului de performanță al furnizorului,
-Variable Name,Numele variabil,
-Parameter Name,Nume parametru,
-Supplier Scorecard Standing,Graficul Scorecard pentru furnizori,
-Notify Other,Notificați alta,
-Supplier Scorecard Variable,Variabila tabelului de variabile pentru furnizori,
-Call Log,Jurnal de Apel,
-Received By,Primit de,
-Caller Information,Informații despre apelant,
-Contact Name,Nume Persoana de Contact,
-Lead ,Conduce,
-Lead Name,Nume Pistă,
-Ringing,țiuit,
-Missed,Pierdute,
-Call Duration in seconds,Durata apelului în câteva secunde,
-Recording URL,Înregistrare URL,
-Communication Medium,Comunicare Mediu,
-Communication Medium Type,Tip mediu de comunicare,
-Voice,Voce,
-Catch All,Prindele pe toate,
-"If there is no assigned timeslot, then communication will be handled by this group","Dacă nu există un interval de timp alocat, comunicarea va fi gestionată de acest grup",
-Timeslots,Intervale de timp,
-Communication Medium Timeslot,Timeslot mediu de comunicare,
-Employee Group,Grupul de angajați,
-Appointment,Programare,
-Scheduled Time,Timpul programat,
-Unverified,neverificat,
-Customer Details,Detalii Client,
-Phone Number,Numar de telefon,
-Skype ID,ID Skype,
-Linked Documents,Documente legate,
-Appointment With,Programare cu,
-Calendar Event,Calendar Eveniment,
-Appointment Booking Settings,Setări rezervare numire,
-Enable Appointment Scheduling,Activați programarea programării,
-Agent Details,Detalii agent,
-Availability Of Slots,Disponibilitatea sloturilor,
-Number of Concurrent Appointments,Numărul de întâlniri simultane,
-Agents,agenţi,
-Appointment Details,Detalii despre numire,
-Appointment Duration (In Minutes),Durata numirii (în proces-verbal),
-Notify Via Email,Notificați prin e-mail,
-Notify customer and agent via email on the day of the appointment.,Notificați clientul și agentul prin e-mail în ziua programării.,
-Number of days appointments can be booked in advance,Numărul de întâlniri de zile poate fi rezervat în avans,
-Success Settings,Setări de succes,
-Success Redirect URL,Adresa URL de redirecționare,
-"Leave blank for home.\nThis is relative to site URL, for example ""about"" will redirect to ""https://yoursitename.com/about""","Lăsați gol pentru casă. Aceasta este relativă la adresa URL a site-ului, de exemplu „despre” se va redirecționa la „https://yoursitename.com/about”",
-Appointment Booking Slots,Rezervare pentru sloturi de rezervare,
-Day Of Week,Zi a Săptămânii,
-From Time ,Din Time,
-Campaign Email Schedule,Program de e-mail al campaniei,
-Send After (days),Trimite După (zile),
-Signed,Semnat,
-Party User,Utilizator de petreceri,
-Unsigned,Nesemnat,
-Fulfilment Status,Starea de îndeplinire,
-N/A,N / A,
-Unfulfilled,neîmplinit,
-Partially Fulfilled,Parțial îndeplinite,
-Fulfilled,Fulfilled,
-Lapsed,caducă,
-Contract Period,Perioada contractuala,
-Signee Details,Signee Detalii,
-Signee,Signee,
-Signed On,Signed On,
-Contract Details,Detaliile contractului,
-Contract Template,Model de contract,
-Contract Terms,Termenii contractului,
-Fulfilment Details,Detalii de execuție,
-Requires Fulfilment,Necesită îndeplinirea,
-Fulfilment Deadline,Termenul de îndeplinire,
-Fulfilment Terms,Condiții de îndeplinire,
-Contract Fulfilment Checklist,Lista de verificare a executării contului,
-Requirement,Cerinţă,
-Contract Terms and Conditions,Termeni și condiții contractuale,
-Fulfilment Terms and Conditions,Condiții și condiții de îndeplinire,
-Contract Template Fulfilment Terms,Termenii de îndeplinire a modelului de contract,
-Email Campaign,Campania de e-mail,
-Email Campaign For ,Campanie prin e-mail,
-Lead is an Organization,Pista este o Organizație,
-CRM-LEAD-.YYYY.-,CRM-LEAD-.YYYY.-,
-Person Name,Nume persoană,
-Lost Quotation,ofertă pierdută,
-Interested,Interesat,
-Converted,Transformat,
-Do Not Contact,Nu contactati,
-From Customer,De la Client,
-Campaign Name,Denumire campanie,
-Follow Up,Urmare,
-Next Contact By,Următor Contact Prin,
-Next Contact Date,Următor Contact Data,
-Ends On,Se termină pe,
-Address & Contact,Adresă și contact,
-Mobile No.,Numar de mobil,
-Lead Type,Tip Pistă,
-Channel Partner,Partner Canal,
-Consultant,Consultant,
-Market Segment,Segmentul de piață,
-Industry,Industrie,
-Request Type,Tip Cerere,
-Product Enquiry,Intrebare produs,
-Request for Information,Cerere de informații,
-Suggestions,Sugestii,
-Blog Subscriber,Abonat blog,
-LinkedIn Settings,Setări LinkedIn,
-Company ID,ID-ul companiei,
-OAuth Credentials,Acreditări OAuth,
-Consumer Key,Cheia consumatorului,
-Consumer Secret,Secretul consumatorului,
-User Details,Detalii utilizator,
-Person URN,Persoana URN,
-Session Status,Starea sesiunii,
-Lost Reason Detail,Detaliu ratiune pierduta,
-Opportunity Lost Reason,Motivul pierdut din oportunitate,
-Potential Sales Deal,Oferta potențiale Vânzări,
-CRM-OPP-.YYYY.-,CRM-OPP-.YYYY.-,
-Opportunity From,Oportunitate de la,
-Customer / Lead Name,Client / Nume Principal,
-Opportunity Type,Tip de oportunitate,
-Converted By,Convertit de,
-Sales Stage,Stadiu Vânzări,
-Lost Reason,Motiv Pierdere,
-Expected Closing Date,Data de închidere preconizată,
-To Discuss,Pentru a discuta,
-With Items,Cu articole,
-Probability (%),Probabilitate (%),
-Contact Info,Informaţii Persoana de Contact,
-Customer / Lead Address,Client / Adresa principala,
-Contact Mobile No,Nr. Mobil Persoana de Contact,
-Enter name of campaign if source of enquiry is campaign,Introduceți numele de campanie dacă sursa de anchetă este campanie,
-Opportunity Date,Oportunitate Data,
-Opportunity Item,Oportunitate Articol,
-Basic Rate,Rată elementară,
-Stage Name,Nume de Scenă,
-Social Media Post,Postare pe rețelele sociale,
-Post Status,Stare postare,
-Posted,Postat,
-Share On,Distribuie pe,
-Twitter,Stare de nervozitate,
-LinkedIn,LinkedIn,
-Twitter Post Id,Codul postării pe Twitter,
-LinkedIn Post Id,Cod postare LinkedIn,
-Tweet,Tweet,
-Twitter Settings,Setări Twitter,
-API Secret Key,Cheia secretă API,
-Term Name,Nume termen,
-Term Start Date,Termenul Data de începere,
-Term End Date,Termenul Data de încheiere,
-Academics User,Utilizator cadru pedagogic,
-Academic Year Name,Nume An Universitar,
-Article,Articol,
-LMS User,Utilizator LMS,
-Assessment Criteria Group,Grup de criterii de evaluare,
-Assessment Group Name,Numele grupului de evaluare,
-Parent Assessment Group,Grup părinte de evaluare,
-Assessment Name,Nume evaluare,
-Grading Scale,Scala de notare,
-Examiner,Examinator,
-Examiner Name,Nume examinator,
-Supervisor,supraveghetor,
-Supervisor Name,Nume supervizor,
-Evaluate,A evalua,
-Maximum Assessment Score,Scor maxim de evaluare,
-Assessment Plan Criteria,Criterii Plan de evaluare,
-Maximum Score,Scor maxim,
-Result,Rezultat,
-Total Score,Scorul total,
-Grade,calitate,
-Assessment Result Detail,Detalii rezultat evaluare,
-Assessment Result Tool,Instrument de Evaluare Rezultat,
-Result HTML,rezultat HTML,
-Content Activity,Activitate de conținut,
-Last Activity ,Ultima activitate,
-Content Question,Întrebare de conținut,
-Question Link,Link de întrebări,
-Course Name,Numele cursului,
-Topics,Subiecte,
-Hero Image,Imaginea eroului,
-Default Grading Scale,Scale Standard Standard folosit,
-Education Manager,Director de educație,
-Course Activity,Activitate de curs,
-Course Enrollment,Înscriere la curs,
-Activity Date,Data activității,
-Course Assessment Criteria,Criterii de evaluare a cursului,
-Weightage,Weightage,
-Course Content,Conținutul cursului,
-Quiz,chestionare,
-Program Enrollment,programul de înscriere,
-Enrollment Date,Data de inscriere,
-Instructor Name,Nume instructor,
-EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-,
-Course Scheduling Tool,Instrument curs de programare,
-Course Start Date,Data începerii cursului,
-To TIme,La timp,
-Course End Date,Desigur Data de încheiere,
-Course Topic,Subiectul cursului,
-Topic,Subiect,
-Topic Name,Nume subiect,
-Education Settings,Setări educaționale,
-Current Academic Year,Anul academic curent,
-Current Academic Term,Termen academic actual,
-Attendance Freeze Date,Data de înghețare a prezenței,
-Validate Batch for Students in Student Group,Validați lotul pentru elevii din grupul de studenți,
-"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Pentru grupul de studenți bazat pe loturi, lotul student va fi validat pentru fiecare student din înscrierea în program.",
-Validate Enrolled Course for Students in Student Group,Validați cursul înscris pentru elevii din grupul de studenți,
-"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.","Pentru grupul de studenți bazat pe cursuri, cursul va fi validat pentru fiecare student din cursurile înscrise în înscrierea în program.",
-Make Academic Term Mandatory,Asigurați-obligatoriu termenul academic,
-"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Dacă este activată, domeniul Academic Term va fi obligatoriu în Instrumentul de înscriere în program.",
-Skip User creation for new Student,Omiteți crearea utilizatorului pentru noul student,
-"By default, a new User is created for every new Student. If enabled, no new User will be created when a new Student is created.","În mod implicit, este creat un nou utilizator pentru fiecare student nou. Dacă este activat, nu va fi creat niciun utilizator nou atunci când este creat un nou student.",
-Instructor Records to be created by,Instructor de înregistrări care urmează să fie create de către,
-Employee Number,Numar angajat,
-Fee Category,Taxă Categorie,
-Fee Component,Taxa de Component,
-Fees Category,Taxele de Categoria,
-Fee Schedule,Taxa de Program,
-Fee Structure,Structura Taxa de,
-EDU-FSH-.YYYY.-,EDU-FSH-.YYYY.-,
-Fee Creation Status,Starea de creare a taxelor,
-In Process,În procesul de,
-Send Payment Request Email,Trimiteți e-mail de solicitare de plată,
-Student Category,Categoria de student,
-Fee Breakup for each student,Taxă pentru fiecare student,
-Total Amount per Student,Suma totală pe student,
-Institution,Instituţie,
-Fee Schedule Program,Programul programului de plăți,
-Student Batch,Lot de student,
-Total Students,Total studenți,
-Fee Schedule Student Group,Taxă Schedule Student Group,
-EDU-FST-.YYYY.-,EDU-FST-.YYYY.-,
-EDU-FEE-.YYYY.-,EDU-FEE-.YYYY.-,
-Include Payment,Includeți plata,
-Send Payment Request,Trimiteți Cerere de Plată,
-Student Details,Detalii studențești,
-Student Email,Student Email,
-Grading Scale Name,Standard Nume Scala,
-Grading Scale Intervals,Intervale de notare Scala,
-Intervals,intervale,
-Grading Scale Interval,Clasificarea Scala Interval,
-Grade Code,Cod grad,
-Threshold,Prag,
-Grade Description,grad Descriere,
-Guardian,gardian,
-Guardian Name,Nume tutore,
-Alternate Number,Număr alternativ,
-Occupation,Ocupaţie,
-Work Address,Adresa de,
-Guardian Of ,Guardian Of,
-Students,Elevi,
-Guardian Interests,Guardian Interese,
-Guardian Interest,Interes tutore,
-Interest,Interes,
-Guardian Student,Guardian Student,
-EDU-INS-.YYYY.-,EDU-INS-.YYYY.-,
-Instructor Log,Jurnalul instructorului,
-Other details,Alte detalii,
-Option,Opțiune,
-Is Correct,Este corect,
-Program Name,Numele programului,
-Program Abbreviation,Abreviere de program,
-Courses,cursuri,
-Is Published,Este publicat,
-Allow Self Enroll,Permiteți înscrierea de sine,
-Is Featured,Este prezentat,
-Intro Video,Introducere video,
-Program Course,Curs Program,
-School House,School House,
-Boarding Student,Student de internare,
-Check this if the Student is residing at the Institute's Hostel.,Verificați dacă studentul este rezident la Hostelul Institutului.,
-Walking,mers,
-Institute's Bus,Biblioteca Institutului,
-Public Transport,Transport public,
-Self-Driving Vehicle,Vehicul cu autovehicul,
-Pick/Drop by Guardian,Pick / Drop de Guardian,
-Enrolled courses,Cursuri înscrise,
-Program Enrollment Course,Curs de înscriere la curs,
-Program Enrollment Fee,Programul de înscriere Taxa,
-Program Enrollment Tool,Programul Instrumentul de înscriere,
-Get Students From,Elevii de la a lua,
-Student Applicant,Solicitantul elev,
-Get Students,Studenți primi,
-Enrollment Details,Detalii de înscriere,
-New Program,programul nou,
-New Student Batch,Noul lot de studenți,
-Enroll Students,Studenți Enroll,
-New Academic Year,Anul universitar nou,
-New Academic Term,Termen nou academic,
-Program Enrollment Tool Student,Programul de înscriere Instrumentul Student,
-Student Batch Name,Nume elev Lot,
-Program Fee,Taxa de program,
-Question,Întrebare,
-Single Correct Answer,Un singur răspuns corect,
-Multiple Correct Answer,Răspuns corect multiplu,
-Quiz Configuration,Configurarea testului,
-Passing Score,Scor de trecere,
-Score out of 100,Scor din 100,
-Max Attempts,Încercări maxime,
-Enter 0 to waive limit,Introduceți 0 până la limita de renunțare,
-Grading Basis,Bazele gradării,
-Latest Highest Score,Cel mai mare scor,
-Latest Attempt,Ultima încercare,
-Quiz Activity,Activitate de testare,
-Enrollment,înrolare,
-Pass,Trece,
-Quiz Question,Întrebare întrebare,
-Quiz Result,Rezultatul testului,
-Selected Option,Opțiunea selectată,
-Correct,Corect,
-Wrong,Gresit,
-Room Name,Nume Cameră,
-Room Number,Număr Cameră,
-Seating Capacity,Numărul de locuri,
-House Name,Numele casei,
-EDU-STU-.YYYY.-,EDU-STU-.YYYY.-,
-Student Mobile Number,Elev Număr mobil,
-Joining Date,Data Angajării,
-Blood Group,Grupă de sânge,
-A+,A+,
-A-,A-,
-B+,B +,
-B-,B-,
-O+,O +,
-O-,O-,
-AB+,AB+,
-AB-,AB-,
-Nationality,Naţionalitate,
-Home Address,Adresa de acasa,
-Guardian Details,Detalii tutore,
-Guardians,tutorii,
-Sibling Details,Detalii sibling,
-Siblings,siblings,
-Exit,Iesire,
-Date of Leaving,Data Părăsirii,
-Leaving Certificate Number,Părăsirea Număr certificat,
-Reason For Leaving,Motivul plecării,
-Student Admission,Admiterea studenților,
-Admission Start Date,Data de începere a Admiterii,
-Admission End Date,Data de încheiere Admiterii,
-Publish on website,Publica pe site-ul,
-Eligibility and Details,Eligibilitate și detalii,
-Student Admission Program,Programul de Admitere în Studenți,
-Minimum Age,Varsta minima,
-Maximum Age,Vârsta maximă,
-Application Fee,Taxă de aplicare,
-Naming Series (for Student Applicant),Seria de denumire (pentru Student Solicitant),
-LMS Only,Numai LMS,
-EDU-APP-.YYYY.-,EDU-APP-.YYYY.-,
-Application Status,Starea aplicației,
-Application Date,Data aplicării,
-Student Attendance Tool,Instrumentul de student Participarea,
-Group Based On,Grup pe baza,
-Students HTML,HTML studenții,
-Group Based on,Grup bazat pe,
-Student Group Name,Numele grupului studențesc,
-Max Strength,Putere max,
-Set 0 for no limit,0 pentru a seta nici o limită,
-Instructors,instructorii,
-Student Group Creation Tool,Instrumentul de creare a grupului de student,
-Leave blank if you make students groups per year,Lăsați necompletat dacă faceți grupuri de elevi pe an,
-Get Courses,Cursuri de a lua,
-Separate course based Group for every Batch,Separați un grup bazat pe cursuri pentru fiecare lot,
-Leave unchecked if you don't want to consider batch while making course based groups. ,Lăsați necontrolabil dacă nu doriți să luați în considerare lotul în timp ce faceți grupuri bazate pe curs.,
-Student Group Creation Tool Course,Curs de grup studențesc instrument de creare,
-Course Code,Codul cursului,
-Student Group Instructor,Student Grup Instructor,
-Student Group Student,Student Group Student,
-Group Roll Number,Numărul rolurilor de grup,
-Student Guardian,student la Guardian,
-Relation,Relație,
-Mother,Mamă,
-Father,tată,
-Student Language,Limba Student,
-Student Leave Application,Aplicație elev Concediul,
-Mark as Present,Marcați ca prezent,
-Student Log,Jurnal de student,
-Academic,Academic,
-Achievement,Realizare,
-Student Report Generation Tool,Instrumentul de generare a rapoartelor elevilor,
-Include All Assessment Group,Includeți tot grupul de evaluare,
-Show Marks,Afișați marcajele,
-Add letterhead,Adăugă Antet,
-Print Section,Imprimare secțiune,
-Total Parents Teacher Meeting,Întâlnire între profesorii de părinți,
-Attended by Parents,Participat de părinți,
-Assessment Terms,Termeni de evaluare,
-Student Sibling,elev Sibling,
-Studying in Same Institute,Studiind în același Institut,
-NO,NU,
-YES,Da,
-Student Siblings,Siblings Student,
-Topic Content,Conținut subiect,
-Amazon MWS Settings,Amazon MWS Settings,
-ERPNext Integrations,Integrări ERPNext,
-Enable Amazon,Activați Amazon,
-MWS Credentials,Certificatele MWS,
-Seller ID,ID-ul vânzătorului,
-AWS Access Key ID,Codul AWS Access Key,
-MWS Auth Token,MWS Auth Token,
-Market Place ID,ID-ul pieței,
-AE,AE,
-AU,AU,
-BR,BR,
-CA,CA,
-CN,CN,
-DE,DE,
-ES,ES,
-FR,FR,
-IN,ÎN,
-JP,JP,
-IT,ACEASTA,
-MX,MX,
-UK,Regatul Unit,
-US,S.U.A.,
-Customer Type,tip de client,
-Market Place Account Group,Grupul de cont de pe piață,
-After Date,După data,
-Amazon will synch data updated after this date,Amazon va sincroniza datele actualizate după această dată,
-Sync Taxes and Charges,Sincronizați taxele și taxele,
-Get financial breakup of Taxes and charges data by Amazon ,Obțineți despărțirea financiară a datelor fiscale și taxe de către Amazon,
-Sync Products,Produse de sincronizare,
-Always sync your products from Amazon MWS before synching the Orders details,Sincronizați întotdeauna produsele dvs. de la Amazon MWS înainte de a sincroniza detaliile comenzilor,
-Sync Orders,Sincronizați comenzile,
-Click this button to pull your Sales Order data from Amazon MWS.,Faceți clic pe acest buton pentru a vă trage datele de comandă de vânzări de la Amazon MWS.,
-Enable Scheduled Sync,Activați sincronizarea programată,
-Check this to enable a scheduled Daily synchronization routine via scheduler,Verificați acest lucru pentru a activa o rutină zilnică de sincronizare programată prin programator,
-Max Retry Limit,Max Retry Limit,
-Exotel Settings,Setări Exotel,
-Account SID,Cont SID,
-API Token,Token API,
-GoCardless Mandate,GoCardless Mandate,
-Mandate,Mandat,
-GoCardless Customer,Clientul GoCardless,
-GoCardless Settings,Setări GoCardless,
-Webhooks Secret,Webhooks Secret,
-Plaid Settings,Setări Plaid,
-Synchronize all accounts every hour,Sincronizați toate conturile în fiecare oră,
-Plaid Client ID,Cod client Plaid,
-Plaid Secret,Plaid Secret,
-Plaid Environment,Mediu plaid,
-sandbox,Sandbox,
-development,dezvoltare,
-production,producție,
-QuickBooks Migrator,QuickBooks Migrator,
-Application Settings,Setările aplicației,
-Token Endpoint,Token Endpoint,
-Scope,domeniu,
-Authorization Settings,Setările de autorizare,
-Authorization Endpoint,Autorizație,
-Authorization URL,Adresa de autorizare,
-Quickbooks Company ID,Coduri de identificare rapidă a companiei,
-Company Settings,Setări Company,
-Default Shipping Account,Contul de transport implicit,
-Default Warehouse,Depozit Implicit,
-Default Cost Center,Centru Cost Implicit,
-Undeposited Funds Account,Contul fondurilor nedeclarate,
-Shopify Log,Magazinul de jurnal,
-Request Data,Solicită Date,
-Shopify Settings,Rafinați setările,
-status html,starea html,
-Enable Shopify,Activați Shopify,
-App Type,Tipul aplicației,
-Last Sync Datetime,Ultima dată de sincronizare,
-Shop URL,Adresa URL magazin,
-eg: frappe.myshopify.com,de ex .: frappe.myshopify.com,
-Shared secret,Secret împărtășit,
-Webhooks Details,Detaliile Webhooks,
-Webhooks,Webhooks,
-Customer Settings,Setările clientului,
-Default Customer,Client Implicit,
-Customer Group will set to selected group while syncing customers from Shopify,Grupul de clienți va seta grupul selectat în timp ce va sincroniza clienții din Shopify,
-For Company,Pentru Companie,
-Cash Account will used for Sales Invoice creation,Contul de numerar va fi utilizat pentru crearea facturii de vânzări,
-Update Price from Shopify To ERPNext Price List,Actualizați prețul de la Shopify la lista de prețuri ERP următoare,
-Default Warehouse to to create Sales Order and Delivery Note,Warehouse implicit pentru a crea o comandă de vânzări și o notă de livrare,
-Sales Order Series,Seria de comandă de vânzări,
-Import Delivery Notes from Shopify on Shipment,Importă note de livrare de la Shopify la expediere,
-Delivery Note Series,Seria de note de livrare,
-Import Sales Invoice from Shopify if Payment is marked,Importă factura de vânzare din Shopify dacă este marcată plata,
-Sales Invoice Series,Seria de facturi de vânzări,
-Shopify Tax Account,Achiziționați contul fiscal,
-Shopify Tax/Shipping Title,Achiziționați titlul fiscal / transport,
-ERPNext Account,Contul ERPNext,
-Shopify Webhook Detail,Bucurați-vă de detaliile Webhook,
-Webhook ID,ID-ul Webhook,
-Tally Migration,Migrația de tip Tally,
-Master Data,Date Master,
-"Data exported from Tally that consists of the Chart of Accounts, Customers, Suppliers, Addresses, Items and UOMs","Date exportate de la Tally care constă din Planul de conturi, clienți, furnizori, adrese, articole și UOM-uri",
-Is Master Data Processed,Sunt prelucrate datele master,
-Is Master Data Imported,Sunt importate datele de master,
-Tally Creditors Account,Contul creditorilor Tally,
-Creditors Account set in Tally,Contul creditorilor stabilit în Tally,
-Tally Debtors Account,Contul debitorilor,
-Debtors Account set in Tally,Contul debitorilor stabilit în Tally,
-Tally Company,Tally Company,
-Company Name as per Imported Tally Data,Numele companiei conform datelor importate Tally,
-Default UOM,UOM implicit,
-UOM in case unspecified in imported data,UOM în cazul nespecificat în datele importate,
-ERPNext Company,Compania ERPNext,
-Your Company set in ERPNext,Compania dvs. a fost setată în ERPNext,
-Processed Files,Fișiere procesate,
-Parties,Petreceri,
-UOMs,UOMs,
-Vouchers,Bonuri,
-Round Off Account,Rotunji cont,
-Day Book Data,Date despre cartea de zi,
-Day Book Data exported from Tally that consists of all historic transactions,"Date din agenda de zi exportate din Tally, care constă în toate tranzacțiile istorice",
-Is Day Book Data Processed,Sunt prelucrate datele despre cartea de zi,
-Is Day Book Data Imported,Sunt importate datele despre cartea de zi,
-Woocommerce Settings,Setări Woocommerce,
-Enable Sync,Activați sincronizarea,
-Woocommerce Server URL,Adresa URL a serverului Woocommerce,
-Secret,Secret,
-API consumer key,Cheia pentru consumatori API,
-API consumer secret,Secretul consumatorului API,
-Tax Account,Contul fiscal,
-Freight and Forwarding Account,Contul de expediere și de expediere,
-Creation User,Utilizator creație,
-"The user that will be used to create Customers, Items and Sales Orders. This user should have the relevant permissions.","Utilizatorul care va fi utilizat pentru a crea clienți, articole și comenzi de vânzare. Acest utilizator ar trebui să aibă permisiunile relevante.",
-"This warehouse will be used to create Sales Orders. The fallback warehouse is ""Stores"".",Acest depozit va fi folosit pentru a crea comenzi de vânzare. Depozitul în retragere este „Magazine”.,
-"The fallback series is ""SO-WOO-"".",Seria Fallback este „SO-WOO-”.,
-This company will be used to create Sales Orders.,Această companie va fi folosită pentru a crea comenzi de vânzare.,
-Delivery After (Days),Livrare după (zile),
-This is the default offset (days) for the Delivery Date in Sales Orders. The fallback offset is 7 days from the order placement date.,Aceasta este compensarea implicită (zile) pentru data livrării în comenzile de vânzare. Decalarea compensării este de 7 zile de la data plasării comenzii.,
-"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".",Acesta este UOM-ul implicit utilizat pentru articole și comenzi de vânzări. UOM-ul în rezervă este „Nos”.,
-Endpoints,Endpoints,
-Endpoint,Punct final,
-Antibiotic Name,Numele antibioticului,
-Healthcare Administrator,Administrator de asistență medicală,
-Laboratory User,Utilizator de laborator,
-Is Inpatient,Este internat,
-Default Duration (In Minutes),Durata implicită (în minute),
-Body Part,Parte a corpului,
-Body Part Link,Legătura părții corpului,
-HLC-CPR-.YYYY.-,HLC-CPR-.YYYY.-,
-Procedure Template,Șablon de procedură,
-Procedure Prescription,Procedura de prescriere,
-Service Unit,Unitate de service,
-Consumables,Consumabile,
-Consume Stock,Consumați stocul,
-Invoice Consumables Separately,Consumabile facturate separat,
-Consumption Invoiced,Consum facturat,
-Consumable Total Amount,Suma totală consumabilă,
-Consumption Details,Detalii despre consum,
-Nursing User,Utilizator Nursing,
-Clinical Procedure Item,Articol de procedură clinică,
-Invoice Separately as Consumables,Factureaza distinct ca si consumabile,
-Transfer Qty,Cantitate transfer,
-Actual Qty (at source/target),Cant. efectivă (la sursă/destinaţie),
-Is Billable,Este facturabil,
-Allow Stock Consumption,Permiteți consumul de stoc,
-Sample UOM,Exemplu UOM,
-Collection Details,Detaliile colecției,
-Change In Item,Modificare element,
-Codification Table,Tabelul de codificare,
-Complaints,Reclamații,
-Dosage Strength,Dozabilitate,
-Strength,Putere,
-Drug Prescription,Droguri de prescripție,
-Drug Name / Description,Denumirea / descrierea medicamentului,
-Dosage,Dozare,
-Dosage by Time Interval,Dozaj după intervalul de timp,
-Interval,Interval,
-Interval UOM,Interval UOM,
-Hour,Oră,
-Update Schedule,Actualizați programul,
-Exercise,Exercițiu,
-Difficulty Level,Nivel de dificultate,
-Counts Target,Numără ținta,
-Counts Completed,Număruri finalizate,
-Assistance Level,Nivelul de asistență,
-Active Assist,Asistență activă,
-Exercise Name,Numele exercițiului,
-Body Parts,Parti ale corpului,
-Exercise Instructions,Instrucțiuni de exerciții,
-Exercise Video,Video de exerciții,
-Exercise Steps,Pași de exerciții,
-Steps,Pași,
-Steps Table,Tabelul Pașilor,
-Exercise Type Step,Tipul exercițiului Pas,
-Max number of visit,Numărul maxim de vizite,
-Visited yet,Vizitată încă,
-Reference Appointments,Programări de referință,
-Valid till,Valabil până la,
-Fee Validity Reference,Referința valabilității taxei,
-Basic Details,Detalii de bază,
-HLC-PRAC-.YYYY.-,HLC-PRAC-.YYYY.-,
-Mobile,Mobil,
-Phone (R),Telefon (R),
-Phone (Office),Telefon (Office),
-Employee and User Details,Detalii despre angajat și utilizator,
-Hospital,Spital,
-Appointments,Programari,
-Practitioner Schedules,Practitioner Schedules,
-Charges,Taxe,
-Out Patient Consulting Charge,Taxă de consultanță pentru pacienți,
-Default Currency,Monedă Implicită,
-Healthcare Schedule Time Slot,Programul de îngrijire a sănătății Time Slot,
-Parent Service Unit,Serviciul pentru părinți,
-Service Unit Type,Tip de unitate de service,
-Allow Appointments,Permiteți întâlnirilor,
-Allow Overlap,Permiteți suprapunerea,
-Inpatient Occupancy,Ocuparea locului de muncă,
-Occupancy Status,Starea ocupației,
-Vacant,Vacant,
-Occupied,Ocupat,
-Item Details,Detalii despre articol,
-UOM Conversion in Hours,Conversie UOM în ore,
-Rate / UOM,Rata / UOM,
-Change in Item,Modificați articolul,
-Out Patient Settings,Setări pentru pacient,
-Patient Name By,Nume pacient,
-Patient Name,Numele pacientului,
-Link Customer to Patient,Conectați clientul la pacient,
-"If checked, a customer will be created, mapped to Patient.\nPatient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.","Dacă este bifată, va fi creat un client, cartografiat pacientului. Facturile de pacienți vor fi create împotriva acestui Client. De asemenea, puteți selecta Clientul existent în timp ce creați pacientul.",
-Default Medical Code Standard,Standardul medical standard standard,
-Collect Fee for Patient Registration,Colectați taxa pentru înregistrarea pacientului,
-Checking this will create new Patients with a Disabled status by default and will only be enabled after invoicing the Registration Fee.,Verificând acest lucru se vor crea noi pacienți cu starea Dezactivat în mod implicit și vor fi activate numai după facturarea Taxei de înregistrare.,
-Registration Fee,Taxă de Înregistrare,
-Automate Appointment Invoicing,Automatizați facturarea programării,
-Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Gestionați trimiterea și anularea facturii de întâlnire în mod automat pentru întâlnirea cu pacienții,
-Enable Free Follow-ups,Activați urmăriri gratuite,
-Number of Patient Encounters in Valid Days,Numărul de întâlniri cu pacienți în zilele valabile,
-The number of free follow ups (Patient Encounters in valid days) allowed,Numărul de urmăriri gratuite (întâlniri cu pacienții în zile valide) permis,
-Valid Number of Days,Număr valid de zile,
-Time period (Valid number of days) for free consultations,Perioada de timp (număr valid de zile) pentru consultări gratuite,
-Default Healthcare Service Items,Articole prestabilite pentru serviciile medicale,
-"You can configure default Items for billing consultation charges, procedure consumption items and inpatient visits","Puteți configura articole implicite pentru facturarea taxelor de consultare, a articolelor de consum procedură și a vizitelor internate",
-Clinical Procedure Consumable Item,Procedura clinică Consumabile,
-Default Accounts,Conturi implicite,
-Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,Conturile de venit implicite care trebuie utilizate dacă nu sunt stabilite în practicienii din domeniul sănătății pentru a rezerva taxele de numire.,
-Default receivable accounts to be used to book Appointment charges.,Conturi de creanță implicite care urmează să fie utilizate pentru rezervarea cheltuielilor pentru programare.,
-Out Patient SMS Alerts,Alerte SMS ale pacientului,
-Patient Registration,Inregistrarea pacientului,
-Registration Message,Mesaj de înregistrare,
-Confirmation Message,Mesaj de confirmare,
-Avoid Confirmation,Evitați confirmarea,
-Do not confirm if appointment is created for the same day,Nu confirmați dacă se creează o întâlnire pentru aceeași zi,
-Appointment Reminder,Memento pentru numire,
-Reminder Message,Mesaj Memento,
-Remind Before,Memento Înainte,
-Laboratory Settings,Setări de laborator,
-Create Lab Test(s) on Sales Invoice Submission,Creați teste de laborator la trimiterea facturilor de vânzări,
-Checking this will create Lab Test(s) specified in the Sales Invoice on submission.,Verificând acest lucru se vor crea teste de laborator specificate în factura de vânzare la trimitere.,
-Create Sample Collection document for Lab Test,Creați un document de colectare a probelor pentru testul de laborator,
-Checking this will create a Sample Collection document  every time you create a Lab Test,"Verificând acest lucru, veți crea un document de colectare a probelor de fiecare dată când creați un test de laborator",
-Employee name and designation in print,Numele și denumirea angajatului în imprimat,
-Check this if you want the Name and Designation of the Employee associated with the User who submits the document to be printed in the Lab Test Report.,Bifați acest lucru dacă doriți ca numele și denumirea angajatului asociate cu utilizatorul care trimite documentul să fie tipărite în raportul de testare de laborator.,
-Do not print or email Lab Tests without Approval,Nu imprimați sau trimiteți prin e-mail testele de laborator fără aprobare,
-Checking this will restrict printing and emailing of Lab Test documents unless they have the status as Approved.,"Verificarea acestui lucru va restricționa imprimarea și trimiterea prin e-mail a documentelor de test de laborator, cu excepția cazului în care acestea au statutul de Aprobat.",
-Custom Signature in Print,Semnătură personalizată în imprimare,
-Laboratory SMS Alerts,Alerte SMS de laborator,
-Result Printed Message,Rezultat Mesaj tipărit,
-Result Emailed Message,Rezultat Mesaj prin e-mail,
-Check In,Verifica,
-Check Out,Verifică,
-HLC-INP-.YYYY.-,HLC-INP-.YYYY.-,
-A Positive,A Pozitive,
-A Negative,Un negativ,
-AB Positive,AB pozitiv,
-AB Negative,AB Negativ,
-B Positive,B pozitiv,
-B Negative,B Negativ,
-O Positive,O pozitiv,
-O Negative,O Negativ,
-Date of birth,Data Nașterii,
-Admission Scheduled,Admiterea programată,
-Discharge Scheduled,Descărcarea programată,
-Discharged,evacuate,
-Admission Schedule Date,Data calendarului de admitere,
-Admitted Datetime,Timpul admis,
-Expected Discharge,Descărcarea anticipată,
-Discharge Date,Data descărcării,
-Lab Prescription,Lab prescription,
-Lab Test Name,Numele testului de laborator,
-Test Created,Testul a fost creat,
-Submitted Date,Data transmisă,
-Approved Date,Data aprobarii,
-Sample ID,ID-ul probelor,
-Lab Technician,Tehnician de laborator,
-Report Preference,Raportați raportul,
-Test Name,Numele testului,
-Test Template,Șablon de testare,
-Test Group,Grupul de testare,
-Custom Result,Rezultate personalizate,
-LabTest Approver,LabTest Approver,
-Add Test,Adăugați test,
-Normal Range,Interval normal,
-Result Format,Formatul rezultatelor,
-Single,Celibatar,
-Compound,Compus,
-Descriptive,Descriptiv,
-Grouped,grupate,
-No Result,Nici un rezultat,
-This value is updated in the Default Sales Price List.,Această valoare este actualizată în lista prestabilită a prețurilor de vânzare.,
-Lab Routine,Laboratorul de rutină,
-Result Value,Valoare Rezultat,
-Require Result Value,Necesita valoarea rezultatului,
-Normal Test Template,Șablonul de test normal,
-Patient Demographics,Demografia pacientului,
-HLC-PAT-.YYYY.-,HLC-PAT-.YYYY.-,
-Middle Name (optional),Prenume (opțional),
-Inpatient Status,Starea staționarului,
-"If ""Link Customer to Patient"" is checked in Healthcare Settings and an existing Customer is not selected then, a Customer will be created for this Patient for recording transactions in Accounts module.","Dacă „Link Client to Pacient” este bifat în Setările asistenței medicale și un Client existent nu este selectat, atunci va fi creat un Client pentru acest Pacient pentru înregistrarea tranzacțiilor în modulul Conturi.",
-Personal and Social History,Istoria personală și socială,
-Marital Status,Stare civilă,
-Married,Căsătorit,
-Divorced,Divorțat/a,
-Widow,Văduvă,
-Patient Relation,Relația pacientului,
-"Allergies, Medical and Surgical History","Alergii, Istorie medicală și chirurgicală",
-Allergies,Alergii,
-Medication,Medicament,
-Medical History,Istoricul medical,
-Surgical History,Istorie chirurgicală,
-Risk Factors,Factori de Risc,
-Occupational Hazards and Environmental Factors,Riscuri Ocupaționale și Factori de Mediu,
-Other Risk Factors,Alți factori de risc,
-Patient Details,Detalii pacient,
-Additional information regarding the patient,Informații suplimentare privind pacientul,
-HLC-APP-.YYYY.-,HLC-APP-.YYYY.-,
-Patient Age,Vârsta pacientului,
-Get Prescribed Clinical Procedures,Obțineți proceduri clinice prescrise,
-Therapy,Terapie,
-Get Prescribed Therapies,Obțineți terapii prescrise,
-Appointment Datetime,Data programării,
-Duration (In Minutes),Durata (în minute),
-Reference Sales Invoice,Factură de vânzare de referință,
-More Info,Mai multe informatii,
-Referring Practitioner,Practicant referitor,
-Reminded,Reamintit,
-HLC-PA-.YYYY.-,HLC-PA-.YYYY.-,
-Assessment Template,Șablon de evaluare,
-Assessment Datetime,Evaluare Datetime,
-Assessment Description,Evaluare Descriere,
-Assessment Sheet,Fișa de evaluare,
-Total Score Obtained,Scorul total obținut,
-Scale Min,Scală Min,
-Scale Max,Scală Max,
-Patient Assessment Detail,Detaliu evaluare pacient,
-Assessment Parameter,Parametru de evaluare,
-Patient Assessment Parameter,Parametrul de evaluare a pacientului,
-Patient Assessment Sheet,Fișa de evaluare a pacientului,
-Patient Assessment Template,Șablon de evaluare a pacientului,
-Assessment Parameters,Parametrii de evaluare,
-Parameters,Parametrii,
-Assessment Scale,Scara de evaluare,
-Scale Minimum,Scala minimă,
-Scale Maximum,Scală maximă,
-HLC-ENC-.YYYY.-,HLC-ENC-.YYYY.-,
-Encounter Date,Data întâlnirii,
-Encounter Time,Întâlniți timpul,
-Encounter Impression,Întâlniți impresiile,
-Symptoms,Simptome,
-In print,În imprimare,
-Medical Coding,Codificarea medicală,
-Procedures,Proceduri,
-Therapies,Terapii,
-Review Details,Detalii de examinare,
-Patient Encounter Diagnosis,Diagnosticul întâlnirii pacientului,
-Patient Encounter Symptom,Simptomul întâlnirii pacientului,
-HLC-PMR-.YYYY.-,HLC-PMR-.YYYY.-,
-Attach Medical Record,Atașați fișa medicală,
-Reference DocType,DocType de referință,
-Spouse,soț,
-Family,Familie,
-Schedule Details,Detalii program,
-Schedule Name,Numele programului,
-Time Slots,Intervale de timp,
-Practitioner Service Unit Schedule,Unitatea Serviciului de Practician,
-Procedure Name,Numele procedurii,
-Appointment Booked,Numirea rezervată,
-Procedure Created,Procedura creată,
-HLC-SC-.YYYY.-,HLC-SC-.YYYY.-,
-Collected By,Colectată de,
-Particulars,Particularități,
-Result Component,Componenta Rezultat,
-HLC-THP-.YYYY.-,HLC-THP-.YYYY.-,
-Therapy Plan Details,Detalii despre planul de terapie,
-Total Sessions,Total sesiuni,
-Total Sessions Completed,Total sesiuni finalizate,
-Therapy Plan Detail,Detaliu plan de terapie,
-No of Sessions,Nr de sesiuni,
-Sessions Completed,Sesiuni finalizate,
-Tele,Tele,
-Exercises,Exerciții,
-Therapy For,Terapie pt,
-Add Exercises,Adăugați exerciții,
-Body Temperature,Temperatura corpului,
-Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Prezența febrei (temperatură&gt; 38,5 ° C sau temperatură susținută&gt; 38 ° C / 100,4 ° F)",
-Heart Rate / Pulse,Ritm cardiac / puls,
-Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Rata pulsului adulților este între 50 și 80 de bătăi pe minut.,
-Respiratory rate,Rata respiratorie,
-Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Intervalul normal de referință pentru un adult este de 16-20 respirații / minut (RCP 2012),
-Tongue,Limbă,
-Coated,Acoperit,
-Very Coated,Foarte acoperit,
-Normal,Normal,
-Furry,Cu blană,
-Cuts,Bucăți,
-Abdomen,Abdomen,
-Bloated,Umflat,
-Fluid,Fluid,
-Constipated,Constipat,
-Reflexes,reflexe,
-Hyper,Hyper,
-Very Hyper,Foarte Hyper,
-One Sided,O singură față,
-Blood Pressure (systolic),Tensiunea arterială (sistolică),
-Blood Pressure (diastolic),Tensiunea arterială (diastolică),
-Blood Pressure,Tensiune arteriala,
-"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Tensiunea arterială normală de repaus la un adult este de aproximativ 120 mmHg sistolică și 80 mmHg diastolică, abreviată &quot;120/80 mmHg&quot;",
-Nutrition Values,Valorile nutriției,
-Height (In Meter),Înălțime (în metri),
-Weight (In Kilogram),Greutate (în kilograme),
-BMI,IMC,
-Hotel Room,Cameră de hotel,
-Hotel Room Type,Tip camera de hotel,
-Capacity,Capacitate,
-Extra Bed Capacity,Capacitatea patului suplimentar,
-Hotel Manager,Hotel Manager,
-Hotel Room Amenity,Hotel Amenity Room,
-Billable,Facturabil,
-Hotel Room Package,Pachetul de camere hotel,
-Amenities,dotări,
-Hotel Room Pricing,Pretul camerei hotelului,
-Hotel Room Pricing Item,Hotel Pricing Room Item,
-Hotel Room Pricing Package,Pachetul pentru tarifarea camerei hotelului,
-Hotel Room Reservation,Rezervarea camerelor hotelului,
-Guest Name,Numele oaspetelui,
-Late Checkin,Încearcă târziu,
-Booked,rezervat,
-Hotel Reservation User,Utilizator rezervare hotel,
-Hotel Room Reservation Item,Rezervare cameră cameră,
-Hotel Settings,Setările hotelului,
-Default Taxes and Charges,Impozite și taxe prestabilite,
-Default Invoice Naming Series,Seria implicită de numire a facturilor,
-Additional Salary,Salariu suplimentar,
-HR,HR,
-HR-ADS-.YY.-.MM.-,HR-ADS-.YY .-. MM.-,
-Salary Component,Componenta de salarizare,
-Overwrite Salary Structure Amount,Suprascrieți suma structurii salariilor,
-Deduct Full Tax on Selected Payroll Date,Reduceți impozitul complet pe data de salarizare selectată,
-Payroll Date,Data salarizării,
-Date on which this component is applied,Data la care se aplică această componentă,
-Salary Slip,Salariul Slip,
-Salary Component Type,Tipul componentei salariale,
-HR User,Utilizator HR,
-Appointment Letter,Scrisoare de programare,
-Job Applicant,Solicitant loc de muncă,
-Applicant Name,Nume solicitant,
-Appointment Date,Data de intalnire,
-Appointment Letter Template,Model de scrisoare de numire,
-Body,Corp,
-Closing Notes,Note de închidere,
-Appointment Letter content,Numire scrisoare conținut,
-Appraisal,Expertiză,
-HR-APR-.YY.-.MM.,HR-APR-.YY.-.MM.,
-Appraisal Template,Model expertiză,
-For Employee Name,Pentru Numele Angajatului,
-Goals,Obiective,
-Total Score (Out of 5),Scor total (din 5),
-"Any other remarks, noteworthy effort that should go in the records.","Orice alte observații, efort remarcabil care ar trebui înregistrate.",
-Appraisal Goal,Obiectiv expertiză,
-Key Responsibility Area,Domeni de Responsabilitate Cheie,
-Weightage (%),Weightage (%),
-Score (0-5),Scor (0-5),
-Score Earned,Scor Earned,
-Appraisal Template Title,Titlu model expertivă,
-Appraisal Template Goal,Obiectiv model expertivă,
-KRA,KRA,
-Key Performance Area,Domeniu de Performanță Cheie,
-HR-ATT-.YYYY.-,HR-ATT-.YYYY.-,
-On Leave,La plecare,
-Work From Home,Lucru de acasă,
-Leave Application,Aplicatie pentru Concediu,
-Attendance Date,Dată prezenţă,
-Attendance Request,Cererea de participare,
-Late Entry,Intrare târzie,
-Early Exit,Iesire timpurie,
-Half Day Date,Jumatate de zi Data,
-On Duty,La datorie,
-Explanation,Explicaţie,
-Compensatory Leave Request,Solicitare de plecare compensatorie,
-Leave Allocation,Alocare Concediu,
-Worked On Holiday,Lucrat în vacanță,
-Work From Date,Lucrul de la data,
-Work End Date,Data terminării lucrării,
-Email Sent To,Email trimis catre,
-Select Users,Selectați Utilizatori,
-Send Emails At,Trimite email-uri La,
-Reminder,Memento,
-Daily Work Summary Group User,Utilizatorul grupului zilnic de lucru sumar,
-email,e-mail,
-Parent Department,Departamentul părinților,
-Leave Block List,Lista Concedii Blocate,
-Days for which Holidays are blocked for this department.,Zile pentru care Sărbătorile sunt blocate pentru acest departament.,
-Leave Approver,Aprobator Concediu,
-Expense Approver,Aprobator Cheltuieli,
-Department Approver,Departamentul Aprobare,
-Approver,Aprobator,
-Required Skills,Aptitudini necesare,
-Skills,Aptitudini,
-Designation Skill,Indemanare de desemnare,
-Skill,Calificare,
-Driver,Conducător auto,
-HR-DRI-.YYYY.-,HR-DRI-.YYYY.-,
-Suspended,Suspendat,
-Transporter,Transporter,
-Applicable for external driver,Aplicabil pentru driverul extern,
-Cellphone Number,Număr de Telefon Mobil,
-License Details,Detalii privind licența,
-License Number,Numărul de licență,
-Issuing Date,Data emiterii,
-Driving License Categories,Categorii de licență de conducere,
-Driving License Category,Categoria permiselor de conducere,
-Fleet Manager,Manager de flotă,
-Driver licence class,Clasa permisului de conducere,
-HR-EMP-,HR-vorba sunt,
-Employment Type,Tip angajare,
-Emergency Contact,Contact de Urgență,
-Emergency Contact Name,Nume de contact de urgență,
-Emergency Phone,Telefon de Urgență,
-ERPNext User,Utilizator ERPNext,
-"System User (login) ID. If set, it will become default for all HR forms.","ID Utilizator Sistem (conectare). Dacă este setat, va deveni implicit pentru toate formularele de resurse umane.",
-Create User Permission,Creați permisiunea utilizatorului,
-This will restrict user access to other employee records,Acest lucru va restricționa accesul utilizatorilor la alte înregistrări ale angajaților,
-Joining Details,Detalii Angajare,
-Offer Date,Oferta Date,
-Confirmation Date,Data de Confirmare,
-Contract End Date,Data de Incheiere Contract,
-Notice (days),Preaviz (zile),
-Date Of Retirement,Data Pensionării,
-Department and Grade,Departamentul și Gradul,
-Reports to,Rapoartează către,
-Attendance and Leave Details,Detalii de participare și concediu,
-Leave Policy,Lasati politica,
-Attendance Device ID (Biometric/RF tag ID),Prezentarea dispozitivului de identificare (biometric / RF tag tag),
-Applicable Holiday List,Listă de concedii aplicabile,
-Default Shift,Schimbare implicită,
-Salary Details,Detalii salariu,
-Salary Mode,Mod de salariu,
-Bank A/C No.,Bancă A/C nr.,
-Health Insurance,Asigurare de sanatate,
-Health Insurance Provider,Asigurari de sanatate,
-Health Insurance No,Asigurări de sănătate nr,
-Prefered Email,E-mail Preferam,
-Personal Email,Personal de e-mail,
-Permanent Address Is,Adresa permanentă este,
-Rented,Închiriate,
-Owned,Deținut,
-Permanent Address,Permanent Adresa,
-Prefered Contact Email,Contact Email Preferam,
-Company Email,E-mail Companie,
-Provide Email Address registered in company,Furnizarea Adresa de email inregistrata in companie,
-Current Address Is,Adresa Actuală Este,
-Current Address,Adresa actuală,
-Personal Bio,Personal Bio,
-Bio / Cover Letter,Bio / Cover Letter,
-Short biography for website and other publications.,Scurta biografie pentru site-ul web și alte publicații.,
-Passport Number,Numărul de pașaport,
-Date of Issue,Data Problemei,
-Place of Issue,Locul eliberării,
-Widowed,Văduvit,
-Family Background,Context familial,
-"Here you can maintain family details like name and occupation of parent, spouse and children","Aici puteți stoca detalii despre familie, cum ar fi numele și ocupația parintelui, sotului/sotiei și copiilor",
-Health Details,Detalii Sănătate,
-"Here you can maintain height, weight, allergies, medical concerns etc","Aici puteți stoca informatii despre inaltime, greutate, alergii, probleme medicale etc",
-Educational Qualification,Detalii Calificare de Învățământ,
-Previous Work Experience,Anterior Work Experience,
-External Work History,Istoricul lucrului externă,
-History In Company,Istoric In Companie,
-Internal Work History,Istoria interne de lucru,
-Resignation Letter Date,Dată Scrisoare de Demisie,
-Relieving Date,Alinarea Data,
-Reason for Leaving,Motiv pentru plecare,
-Leave Encashed?,Concediu Incasat ?,
-Encashment Date,Data plata in Numerar,
-New Workplace,Nou loc de muncă,
-HR-EAD-.YYYY.-,HR-EAD-.YYYY.-,
-Returned Amount,Suma restituită,
-Claimed,Revendicat,
-Advance Account,Advance Account,
-Employee Attendance Tool,Instrumentul Participarea angajat,
-Unmarked Attendance,Participarea nemarcat,
-Employees HTML,Angajații HTML,
-Marked Attendance,Participarea marcat,
-Marked Attendance HTML,Participarea marcat HTML,
-Employee Benefit Application,Aplicația pentru beneficiile angajaților,
-Max Benefits (Yearly),Beneficii maxime (anual),
-Remaining Benefits (Yearly),Alte beneficii (anuale),
-Payroll Period,Perioada de salarizare,
-Benefits Applied,Beneficii aplicate,
-Dispensed Amount (Pro-rated),Sumă distribuită (Pro-evaluată),
-Employee Benefit Application Detail,Detaliile aplicației pentru beneficiile angajaților,
-Earning Component,Componenta câștigurilor,
-Pay Against Benefit Claim,Plătiți împotriva revendicării beneficiilor,
-Max Benefit Amount,Suma maximă a beneficiilor,
-Employee Benefit Claim,Revendicarea beneficiilor pentru angajați,
-Claim Date,Data revendicării,
-Benefit Type and Amount,Tip de prestație și sumă,
-Claim Benefit For,Revendicați beneficiul pentru,
-Max Amount Eligible,Sumă maximă eligibilă,
-Expense Proof,Cheltuieli de probă,
-Employee Boarding Activity,Activitatea de îmbarcare a angajaților,
-Activity Name,Nume Activitate,
-Task Weight,sarcina Greutate,
-Required for Employee Creation,Necesar pentru crearea angajaților,
-Applicable in the case of Employee Onboarding,Aplicabil în cazul angajării angajaților,
-Employee Checkin,Verificarea angajatilor,
-Log Type,Tip jurnal,
-OUT,OUT,
-Location / Device ID,Locație / ID dispozitiv,
-Skip Auto Attendance,Treci la prezența automată,
-Shift Start,Start Shift,
-Shift End,Shift End,
-Shift Actual Start,Shift Start inițial,
-Shift Actual End,Schimbare finală efectivă,
-Employee Education,Educație Angajat,
-School/University,Școlar / universitar,
-Graduate,Absolvent,
-Post Graduate,Postuniversitar,
-Under Graduate,Sub Absolvent,
-Year of Passing,Ani de la promovarea,
-Class / Percentage,Clasă / Procent,
-Major/Optional Subjects,Subiecte Majore / Opționale,
-Employee External Work History,Istoric Extern Locuri de Munca Angajat,
-Total Experience,Experiența totală,
-Default Leave Policy,Implicit Politica de plecare,
-Default Salary Structure,Structura salarială implicită,
-Employee Group Table,Tabelul grupului de angajați,
-ERPNext User ID,ID utilizator ERPNext,
-Employee Health Insurance,Angajarea Asigurărilor de Sănătate,
-Health Insurance Name,Nume de Asigurări de Sănătate,
-Employee Incentive,Angajament pentru angajați,
-Incentive Amount,Sumă stimulativă,
-Employee Internal Work History,Istoric Intern Locuri de Munca Angajat,
-Employee Onboarding,Angajarea la bord,
-Notify users by email,Notifica utilizatorii prin e-mail,
-Employee Onboarding Template,Formularul de angajare a angajatului,
-Activities,Activități,
-Employee Onboarding Activity,Activitatea de angajare a angajaților,
-Employee Other Income,Alte venituri ale angajaților,
-Employee Promotion,Promovarea angajaților,
-Promotion Date,Data promoției,
-Employee Promotion Details,Detaliile de promovare a angajaților,
-Employee Promotion Detail,Detaliile de promovare a angajaților,
-Employee Property History,Istoricul proprietății angajatului,
-Employee Separation,Separarea angajaților,
-Employee Separation Template,Șablon de separare a angajaților,
-Exit Interview Summary,Exit Interviu Rezumat,
-Employee Skill,Indemanarea angajatilor,
-Proficiency,Experiență,
-Evaluation Date,Data evaluării,
-Employee Skill Map,Harta de îndemânare a angajaților,
-Employee Skills,Abilități ale angajaților,
-Trainings,instruiri,
-Employee Tax Exemption Category,Angajament categoria de scutire fiscală,
-Max Exemption Amount,Suma maximă de scutire,
-Employee Tax Exemption Declaration,Declarația de scutire fiscală a angajaților,
-Declarations,Declaraţii,
-Total Declared Amount,Suma totală declarată,
-Total Exemption Amount,Valoarea totală a scutirii,
-Employee Tax Exemption Declaration Category,Declarația de scutire fiscală a angajaților,
-Exemption Sub Category,Scutirea subcategoria,
-Exemption Category,Categoria de scutire,
-Maximum Exempted Amount,Suma maximă scutită,
-Declared Amount,Suma declarată,
-Employee Tax Exemption Proof Submission,Sustine gratuitatea acestui serviciu si acceseaza,
-Submission Date,Data depunerii,
-Tax Exemption Proofs,Dovezi privind scutirea de taxe,
-Total Actual Amount,Suma totală reală,
-Employee Tax Exemption Proof Submission Detail,Angajamentul de scutire fiscală Detaliu de prezentare a probelor,
-Maximum Exemption Amount,Suma maximă de scutire,
-Type of Proof,Tip de probă,
-Actual Amount,Suma reală,
-Employee Tax Exemption Sub Category,Scutirea de impozit pe categorii de angajați,
-Tax Exemption Category,Categoria de scutire de taxe,
-Employee Training,Instruirea angajaților,
-Training Date,Data formării,
-Employee Transfer,Transfer de angajați,
-Transfer Date,Data transferului,
-Employee Transfer Details,Detaliile transferului angajatului,
-Employee Transfer Detail,Detalii despre transferul angajatului,
-Re-allocate Leaves,Re-alocarea frunzelor,
-Create New Employee Id,Creați un nou număr de angajați,
-New Employee ID,Codul angajatului nou,
-Employee Transfer Property,Angajamentul transferului de proprietate,
-HR-EXP-.YYYY.-,HR-EXP-.YYYY.-,
-Expense Taxes and Charges,Cheltuiește impozite și taxe,
-Total Sanctioned Amount,Suma totală sancționat,
-Total Advance Amount,Suma totală a avansului,
-Total Claimed Amount,Total suma pretinsă,
-Total Amount Reimbursed,Total suma rambursată,
-Vehicle Log,vehicul Log,
-Employees Email Id,Id Email Angajat,
-More Details,Mai multe detalii,
-Expense Claim Account,Cont Solicitare Cheltuială,
-Expense Claim Advance,Avans Solicitare Cheltuială,
-Unclaimed amount,Sumă nerevendicată,
-Expense Claim Detail,Detaliu Solicitare Cheltuială,
-Expense Date,Data cheltuieli,
-Expense Claim Type,Tip Solicitare Cheltuială,
-Holiday List Name,Denumire Lista de Vacanță,
-Total Holidays,Total sărbători,
-Add Weekly Holidays,Adăugă Sărbători Săptămânale,
-Weekly Off,Săptămânal Off,
-Add to Holidays,Adăugă la Sărbători,
-Holidays,Concedii,
-Clear Table,Sterge Masa,
-HR Settings,Setări Resurse Umane,
-Employee Settings,Setări Angajat,
-Retirement Age,Vârsta de pensionare,
-Enter retirement age in years,Introdu o vârsta de pensionare în anii,
-Stop Birthday Reminders,De oprire de naștere Memento,
-Expense Approver Mandatory In Expense Claim,Aprobator Cheltuieli Obligatoriu în Solicitare Cheltuială,
-Payroll Settings,Setări de salarizare,
-Leave,Părăsi,
-Max working hours against Timesheet,Max ore de lucru împotriva Pontaj,
-Include holidays in Total no. of Working Days,Includ vacanțe în total nr. de zile lucrătoare,
-"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","In cazul in care se bifeaza, nr. total de zile lucratoare va include si sarbatorile, iar acest lucru va reduce valoarea Salariul pe Zi",
-"If checked, hides and disables Rounded Total field in Salary Slips","Dacă este bifat, ascunde și dezactivează câmpul total rotunjit din Slips-uri de salariu",
-The fraction of daily wages to be paid for half-day attendance,Fracțiunea salariilor zilnice care trebuie plătită pentru participarea la jumătate de zi,
-Email Salary Slip to Employee,E-mail Salariu Slip angajatului,
-Emails salary slip to employee based on preferred email selected in Employee,alunecare email-uri salariul angajatului în funcție de e-mail preferat selectat în Angajat,
-Encrypt Salary Slips in Emails,Criptați diapozitive de salariu în e-mailuri,
-"The salary slip emailed to the employee will be password protected, the password will be generated based on the password policy.","Fișa de salariu trimisă către angajat va fi protejată prin parolă, parola va fi generată pe baza politicii de parolă.",
-Password Policy,Politica de parolă,
-<b>Example:</b> SAL-{first_name}-{date_of_birth.year} <br>This will generate a password like SAL-Jane-1972,<b>Exemplu:</b> SAL- {first_name} - {date_of_birth.year} <br> Aceasta va genera o parolă precum SAL-Jane-1972,
-Leave Settings,Lăsați Setările,
-Leave Approval Notification Template,Lăsați șablonul de notificare de aprobare,
-Leave Status Notification Template,Părăsiți șablonul de notificare a statutului,
-Role Allowed to Create Backdated Leave Application,Rolul permis pentru a crea o cerere de concediu retardat,
-Leave Approver Mandatory In Leave Application,Concedierea obligatorie la cerere,
-Show Leaves Of All Department Members In Calendar,Afișați frunzele tuturor membrilor departamentului în calendar,
-Auto Leave Encashment,Auto Encashment,
-Hiring Settings,Setări de angajare,
-Check Vacancies On Job Offer Creation,Verificați posturile vacante pentru crearea ofertei de locuri de muncă,
-Identification Document Type,Tipul documentului de identificare,
-Effective from,Efectiv de la,
-Allow Tax Exemption,Permiteți scutirea de taxe,
-"If enabled, Tax Exemption Declaration will be considered for income tax calculation.","Dacă este activată, Declarația de scutire de impozit va fi luată în considerare pentru calcularea impozitului pe venit.",
-Standard Tax Exemption Amount,Suma standard de scutire de impozit,
-Taxable Salary Slabs,Taxe salariale,
-Taxes and Charges on Income Tax,Impozite și taxe pe impozitul pe venit,
-Other Taxes and Charges,Alte impozite și taxe,
-Income Tax Slab Other Charges,Impozitul pe venit Slab Alte taxe,
-Min Taxable Income,Venit minim impozabil,
-Max Taxable Income,Venitul maxim impozabil,
-Applicant for a Job,Solicitant pentru un loc de muncă,
-Accepted,Acceptat,
-Job Opening,Loc de munca disponibil,
-Cover Letter,Scrisoare de intenție,
-Resume Attachment,CV-Atașamentul,
-Job Applicant Source,Sursă Solicitant Loc de Muncă,
-Applicant Email Address,Adresa de e-mail a solicitantului,
-Awaiting Response,Se aşteaptă răspuns,
-Job Offer Terms,Condiții Ofertă de Muncă,
-Select Terms and Conditions,Selectați Termeni și condiții,
-Printing Details,Imprimare Detalii,
-Job Offer Term,Termen Ofertă de Muncă,
-Offer Term,Termen oferta,
-Value / Description,Valoare / Descriere,
-Description of a Job Opening,Descrierea unei slujbe,
-Job Title,Denumire Post,
-Staffing Plan,Planul de personal,
-Planned number of Positions,Număr planificat de poziții,
-"Job profile, qualifications required etc.","Profilul postului, calificări necesare, etc",
-HR-LAL-.YYYY.-,HR-LAL-.YYYY.-,
-Allocation,Alocare,
-New Leaves Allocated,Cereri noi de concediu alocate,
-Add unused leaves from previous allocations,Adăugați zile de concediu neutilizate de la alocări anterioare,
-Unused leaves,Frunze neutilizate,
-Total Leaves Allocated,Totalul Frunze alocate,
-Total Leaves Encashed,Frunze totale încorporate,
-Leave Period,Lăsați perioada,
-Carry Forwarded Leaves,Trasmite Concedii Inaintate,
-Apply / Approve Leaves,Aplicați / aprobaţi concedii,
-HR-LAP-.YYYY.-,HR-LAP-.YYYY.-,
-Leave Balance Before Application,Balanta Concediu Inainte de Aplicare,
-Total Leave Days,Total de zile de concediu,
-Leave Approver Name,Lăsați Nume aprobator,
-Follow via Email,Urmați prin e-mail,
-Block Holidays on important days.,Blocaţi zile de sărbătoare în zilele importante.,
-Leave Block List Name,Denumire Lista Concedii Blocate,
-Applies to Company,Se aplică companiei,
-"If not checked, the list will have to be added to each Department where it has to be applied.","In cazul in care este debifat, lista va trebui să fie adăugata fiecarui Departament unde trebuie sa fie aplicată.",
-Block Days,Zile de blocare,
-Stop users from making Leave Applications on following days.,Opri utilizatorii de la a face aplicații concediu pentru următoarele zile.,
-Leave Block List Dates,Date Lista Concedii Blocate,
-Allow Users,Permiteți utilizatori,
-Allow the following users to approve Leave Applications for block days.,Permiteţi următorilor utilizatori să aprobe cereri de concediu pentru zile blocate.,
-Leave Block List Allowed,Lista Concedii Blocate Permise,
-Leave Block List Allow,Permite Lista Concedii Blocate,
-Allow User,Permiteţi utilizator,
-Leave Block List Date,Data Lista Concedii Blocate,
-Block Date,Dată blocare,
-Leave Control Panel,Panou de Control Concediu,
-Select Employees,Selectați angajati,
-Employment Type (optional),Tip de angajare (opțional),
-Branch (optional),Sucursală (opțional),
-Department (optional),Departamentul (opțional),
-Designation (optional),Desemnare (opțional),
-Employee Grade (optional),Gradul angajatului (opțional),
-Employee (optional),Angajat (opțional),
-Allocate Leaves,Alocați frunzele,
-Carry Forward,Transmite Inainte,
-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,
-New Leaves Allocated (In Days),Cereri noi de concediu alocate (în zile),
-Allocate,Alocaţi,
-Leave Balance,Lasă balanța,
-Encashable days,Zile încorporate,
-Encashment Amount,Suma de încasare,
-Leave Ledger Entry,Lăsați intrarea în evidență,
-Transaction Name,Numele tranzacției,
-Is Carry Forward,Este Carry Forward,
-Is Expired,Este expirat,
-Is Leave Without Pay,Este concediu fără plată,
-Holiday List for Optional Leave,Lista de vacanță pentru concediul opțional,
-Leave Allocations,Lăsați alocările,
-Leave Policy Details,Lăsați detaliile politicii,
-Leave Policy Detail,Lăsați detaliile politicii,
-Annual Allocation,Alocarea anuală,
-Leave Type Name,Denumire Tip Concediu,
-Max Leaves Allowed,Frunzele maxime sunt permise,
-Applicable After (Working Days),Aplicabil după (zile lucrătoare),
-Maximum Continuous Days Applicable,Zilele maxime continue sunt aplicabile,
-Is Optional Leave,Este concediu opțională,
-Allow Negative Balance,Permiteţi sold negativ,
-Include holidays within leaves as leaves,Includ zilele de sărbătoare în frunze ca frunze,
-Is Compensatory,Este compensatorie,
-Maximum Carry Forwarded Leaves,Frunze transmise maxim transportat,
-Expire Carry Forwarded Leaves (Days),Expirați transportați frunzele transmise (zile),
-Calculated in days,Calculat în zile,
-Encashment,Încasare,
-Allow Encashment,Permiteți încorporarea,
-Encashment Threshold Days,Zilele pragului de încasare,
-Earned Leave,Salariu câștigat,
-Is Earned Leave,Este lăsat câștigat,
-Earned Leave Frequency,Frecvența de plecare câștigată,
-Rounding,Rotunjire,
-Payroll Employee Detail,Detaliile salariaților salariați,
-Payroll Frequency,Frecventa de salarizare,
-Fortnightly,bilunară,
-Bimonthly,Bilunar,
-Employees,Numar de angajati,
-Number Of Employees,Numar de angajati,
-Employee Details,Detalii angajaților,
-Validate Attendance,Validați participarea,
-Salary Slip Based on Timesheet,Bazat pe salariu Slip Pontaj,
-Select Payroll Period,Perioada de selectare Salarizare,
-Deduct Tax For Unclaimed Employee Benefits,Deducerea Impozitelor Pentru Beneficiile Nerecuperate ale Angajaților,
-Deduct Tax For Unsubmitted Tax Exemption Proof,Deducerea impozitului pentru dovada scutirii fiscale neimpozitate,
-Select Payment Account to make Bank Entry,Selectați Cont de plăți pentru a face Banca de intrare,
-Salary Slips Created,Slipsuri salariale create,
-Salary Slips Submitted,Salariile trimise,
-Payroll Periods,Perioade de salarizare,
-Payroll Period Date,Data perioadei de salarizare,
-Purpose of Travel,Scopul călătoriei,
-Retention Bonus,Bonus de Retenție,
-Bonus Payment Date,Data de plată Bonus,
-Bonus Amount,Bonus Suma,
-Abbr,Presc,
-Depends on Payment Days,Depinde de Zilele de plată,
-Is Tax Applicable,Taxa este aplicabilă,
-Variable Based On Taxable Salary,Variabilă pe salariu impozabil,
-Exempted from Income Tax,Scutit de impozitul pe venit,
-Round to the Nearest Integer,Rotund la cel mai apropiat număr întreg,
-Statistical Component,Componenta statistică,
-"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Dacă este selectată, valoarea specificată sau calculată în această componentă nu va contribui la câștigurile sau deducerile. Cu toate acestea, valoarea sa poate fi menționată de alte componente care pot fi adăugate sau deduse.",
-Do Not Include in Total,Nu includeți în total,
-Flexible Benefits,Beneficii flexibile,
-Is Flexible Benefit,Este benefică flexibilă,
-Max Benefit Amount (Yearly),Sumă maximă pentru beneficiu (anual),
-Only Tax Impact (Cannot Claim But Part of Taxable Income),"Numai impactul fiscal (nu poate fi revendicat, ci parte din venitul impozabil)",
-Create Separate Payment Entry Against Benefit Claim,Creați o intrare separată de plată împotriva revendicării beneficiilor,
-Condition and Formula,Condiție și formulă,
-Amount based on formula,Suma bazată pe formula generală,
-Formula,Formulă,
-Salary Detail,Detalii salariu,
-Component,component,
-Do not include in total,Nu includeți în total,
-Default Amount,Sumă Implicită,
-Additional Amount,Suma suplimentară,
-Tax on flexible benefit,Impozitul pe beneficii flexibile,
-Tax on additional salary,Impozit pe salariu suplimentar,
-Salary Structure,Structura salariu,
-Working Days,Zile lucratoare,
-Salary Slip Timesheet,Salariu alunecare Pontaj,
-Total Working Hours,Numărul total de ore de lucru,
-Hour Rate,Rata Oră,
-Bank Account No.,Cont bancar nr.,
-Earning & Deduction,Câștig Salarial si Deducere,
-Earnings,Câștiguri,
-Deductions,Deduceri,
-Loan repayment,Rambursare a creditului,
-Employee Loan,angajat de împrumut,
-Total Principal Amount,Sumă totală principală,
-Total Interest Amount,Suma totală a dobânzii,
-Total Loan Repayment,Rambursarea totală a creditului,
-net pay info,info net pay,
-Gross Pay - Total Deduction - Loan Repayment,Plata brută - Deducerea totală - rambursare a creditului,
-Total in words,Total în cuvinte,
-Net Pay (in words) will be visible once you save the Salary Slip.,Pay net (în cuvinte) vor fi vizibile după ce salvați fluturasul de salariu.,
-Salary Component for timesheet based payroll.,Componenta de salarizare pentru salarizare bazate pe timesheet.,
-Leave Encashment Amount Per Day,Părăsiți Suma de Invenție pe Zi,
-Max Benefits (Amount),Beneficii maxime (suma),
-Salary breakup based on Earning and Deduction.,Salariul despartire bazat privind câștigul salarial și deducere.,
-Total Earning,Câștigul salarial total de,
-Salary Structure Assignment,Structura salarială,
-Shift Assignment,Schimbare asignare,
-Shift Type,Tip Shift,
-Shift Request,Cerere de schimbare,
-Enable Auto Attendance,Activați prezența automată,
-Mark attendance based on 'Employee Checkin' for Employees assigned to this shift.,Marcați prezența pe baza „Verificării angajaților” pentru angajații repartizați în această schimbă.,
-Auto Attendance Settings,Setări de prezență automată,
-Determine Check-in and Check-out,Determinați check-in și check-out,
-Alternating entries as IN and OUT during the same shift,Alternarea intrărilor ca IN și OUT în timpul aceleiași deplasări,
-Strictly based on Log Type in Employee Checkin,Strict bazat pe tipul de jurnal în verificarea angajaților,
-Working Hours Calculation Based On,Calculul orelor de lucru bazat pe,
-First Check-in and Last Check-out,Primul check-in și ultimul check-out,
-Every Valid Check-in and Check-out,Fiecare check-in și check-out valabil,
-Begin check-in before shift start time (in minutes),Începeți check-in-ul înainte de ora de începere a schimbului (în minute),
-The time before the shift start time during which Employee Check-in is considered for attendance.,Timpul înainte de ora de începere a schimbului în timpul căruia se consideră check-in-ul angajaților pentru participare.,
-Allow check-out after shift end time (in minutes),Permite check-out după ora de încheiere a schimbului (în minute),
-Time after the end of shift during which check-out is considered for attendance.,Timpul după încheierea turei în timpul căreia se face check-out pentru participare.,
-Working Hours Threshold for Half Day,Prag de lucru pentru o jumătate de zi,
-Working hours below which Half Day is marked. (Zero to disable),Ore de lucru sub care este marcată jumătate de zi. (Zero dezactivat),
-Working Hours Threshold for Absent,Prag de lucru pentru orele absente,
-Working hours below which Absent is marked. (Zero to disable),Ore de lucru sub care este marcat absentul. (Zero dezactivat),
-Process Attendance After,Prezență la proces după,
-Attendance will be marked automatically only after this date.,Participarea va fi marcată automat numai după această dată.,
-Last Sync of Checkin,Ultima sincronizare a checkin-ului,
-Last Known Successful Sync of Employee Checkin. Reset this only if you are sure that all Logs are synced from all the locations. Please don't modify this if you are unsure.,Ultima sincronizare cunoscută cu succes a verificării angajaților. Resetați acest lucru numai dacă sunteți sigur că toate jurnalele sunt sincronizate din toate locațiile. Vă rugăm să nu modificați acest lucru dacă nu sunteți sigur.,
-Grace Period Settings For Auto Attendance,Setări pentru perioada de grație pentru prezența automată,
-Enable Entry Grace Period,Activați perioada de grație de intrare,
-Late Entry Grace Period,Perioada de grație de intrare târzie,
-The time after the shift start time when check-in is considered as late (in minutes).,"Ora după ora de începere a schimbului, când check-in este considerată întârziată (în minute).",
-Enable Exit Grace Period,Activați Perioada de grație de ieșire,
-Early Exit Grace Period,Perioada de grație de ieșire timpurie,
-The time before the shift end time when check-out is considered as early (in minutes).,"Timpul înainte de ora de încheiere a schimbului, când check-out-ul este considerat mai devreme (în minute).",
-Skill Name,Nume de îndemânare,
-Staffing Plan Details,Detaliile planului de personal,
-Staffing Plan Detail,Detaliile planului de personal,
-Total Estimated Budget,Bugetul total estimat,
-Vacancies,Posturi vacante,
-Estimated Cost Per Position,Costul estimat pe poziție,
-Total Estimated Cost,Costul total estimat,
-Current Count,Contorul curent,
-Current Openings,Deschideri curente,
-Number Of Positions,Numărul de poziții,
-Taxable Salary Slab,Taxable Salary Slab,
-From Amount,Din Sumă,
-To Amount,La suma,
-Percent Deduction,Deducție procentuală,
-Training Program,Program de antrenament,
-Event Status,Stare eveniment,
-Has Certificate,Are certificat,
-Seminar,Seminar,
-Theory,Teorie,
-Workshop,Atelier,
-Conference,Conferinţă,
-Exam,Examen,
-Internet,Internet,
-Self-Study,Studiu individual,
-Advance,Avans,
-Trainer Name,Nume formator,
-Trainer Email,trainer e-mail,
-Attendees,Participanți,
-Employee Emails,E-mailuri ale angajaților,
-Training Event Employee,Eveniment de formare Angajat,
-Invited,invitați,
-Feedback Submitted,Feedbackul a fost trimis,
-Optional,facultativ,
-Training Result Employee,Angajat de formare Rezultat,
-Travel Itinerary,Itinerariul de călătorie,
-Travel From,Călătorie de la,
-Travel To,Călători în,
-Mode of Travel,Modul de călătorie,
-Flight,Zbor,
-Train,Tren,
-Taxi,Taxi,
-Rented Car,Mașină închiriată,
-Meal Preference,Preferința de mâncare,
-Vegetarian,Vegetarian,
-Non-Vegetarian,Non vegetarian,
-Gluten Free,Fara gluten,
-Non Diary,Non-jurnal,
-Travel Advance Required,Advance Travel Required,
-Departure Datetime,Data plecării,
-Arrival Datetime,Ora de sosire,
-Lodging Required,Cazare solicitată,
-Preferred Area for Lodging,Zonă preferată de cazare,
-Check-in Date,Data înscrierii,
-Check-out Date,Verifica data,
-Travel Request,Cerere de călătorie,
-Travel Type,Tip de călătorie,
-Domestic,Intern,
-International,Internaţional,
-Travel Funding,Finanțarea turismului,
-Require Full Funding,Solicitați o finanțare completă,
-Fully Sponsored,Sponsorizat complet,
-"Partially Sponsored, Require Partial Funding","Parțial sponsorizat, necesită finanțare parțială",
-Copy of Invitation/Announcement,Copia invitatiei / anuntului,
-"Details of Sponsor (Name, Location)","Detalii despre sponsor (nume, locație)",
-Identification Document Number,Cod Numeric Personal,
-Any other details,Orice alte detalii,
-Costing Details,Costul detaliilor,
-Costing,Cost,
-Event Details,detaliile evenimentului,
-Name of Organizer,Numele organizatorului,
-Address of Organizer,Adresa organizatorului,
-Travel Request Costing,Costul cererii de călătorie,
-Expense Type,Tipul de cheltuieli,
-Sponsored Amount,Suma sponsorizată,
-Funded Amount,Sumă finanțată,
-Upload Attendance,Încărcați Spectatori,
-Attendance From Date,Prezenţa de la data,
-Attendance To Date,Prezenţa până la data,
-Get Template,Obține șablon,
-Import Attendance,Import Spectatori,
-Upload HTML,Încărcați HTML,
-Vehicle,Vehicul,
-License Plate,Înmatriculare,
-Odometer Value (Last),Valoarea contorului de parcurs (Ultimul),
-Acquisition Date,Data achiziției,
-Chassis No,Nr. Șasiu,
-Vehicle Value,Valoarea vehiculului,
-Insurance Details,Detalii de asigurare,
-Insurance Company,Companie de asigurari,
-Policy No,Politica nr,
-Additional Details,Detalii suplimentare,
-Fuel Type,Tipul combustibilului,
-Petrol,Benzină,
-Diesel,Diesel,
-Natural Gas,Gaz natural,
-Electric,Electric,
-Fuel UOM,combustibil UOM,
-Last Carbon Check,Ultima Verificare carbon,
-Wheels,roţi,
-Doors,Usi,
-HR-VLOG-.YYYY.-,HR-VLOG-.YYYY.-,
-Odometer Reading,Kilometrajul,
-Current Odometer value ,Valoarea actuală a contorului,
-last Odometer Value ,ultima valoare Odometru,
-Refuelling Details,Detalii de realimentare,
-Invoice Ref,Ref factură,
-Service Details,Detalii de serviciu,
-Service Detail,Detaliu serviciu,
-Vehicle Service,Serviciu de vehicule,
-Service Item,Postul de servicii,
-Brake Oil,Ulei de frână,
-Brake Pad,Pad de frână,
-Clutch Plate,Placă de ambreiaj,
-Engine Oil,Ulei de motor,
-Oil Change,Schimbare de ulei,
-Inspection,Inspecţie,
-Mileage,distanță parcursă,
-Hub Tracked Item,Articol urmărit,
-Hub Node,Hub Node,
-Image List,Listă de imagini,
-Item Manager,Postul de manager,
-Hub User,Utilizator Hub,
-Hub Password,Parola Hub,
-Hub Users,Hub utilizatori,
-Marketplace Settings,Setări pentru piață,
-Disable Marketplace,Dezactivați Marketplace,
-Marketplace URL (to hide and update label),Adresa URL de pe piață (pentru ascunderea și actualizarea etichetei),
-Registered,Înregistrat,
-Sync in Progress,Sincronizați în curs,
-Hub Seller Name,Numele vânzătorului Hub,
-Custom Data,Date personalizate,
-Member,Membru,
-Partially Disbursed,parţial Se eliberează,
-Loan Closure Requested,Solicitare de închidere a împrumutului,
-Repay From Salary,Rambursa din salariu,
-Loan Details,Creditul Detalii,
-Loan Type,Tip credit,
-Loan Amount,Sumă împrumutată,
-Is Secured Loan,Este împrumut garantat,
-Rate of Interest (%) / Year,Rata dobânzii (%) / An,
-Disbursement Date,debursare,
-Disbursed Amount,Suma plătită,
-Is Term Loan,Este împrumut pe termen,
-Repayment Method,Metoda de rambursare,
-Repay Fixed Amount per Period,Rambursa Suma fixă pentru fiecare perioadă,
-Repay Over Number of Periods,Rambursa Peste Număr de Perioade,
-Repayment Period in Months,Rambursarea Perioada în luni,
-Monthly Repayment Amount,Suma de rambursare lunar,
-Repayment Start Date,Data de începere a rambursării,
-Loan Security Details,Detalii privind securitatea împrumutului,
-Maximum Loan Value,Valoarea maximă a împrumutului,
-Account Info,Informaţii cont,
-Loan Account,Contul împrumutului,
-Interest Income Account,Contul Interes Venit,
-Penalty Income Account,Cont de venituri din penalități,
-Repayment Schedule,rambursare Program,
-Total Payable Amount,Suma totală de plată,
-Total Principal Paid,Total plătit principal,
-Total Interest Payable,Dobânda totală de plată,
-Total Amount Paid,Suma totală plătită,
-Loan Manager,Managerul de împrumut,
-Loan Info,Creditul Info,
-Rate of Interest,Rata Dobânzii,
-Proposed Pledges,Promisiuni propuse,
-Maximum Loan Amount,Suma maximă a împrumutului,
-Repayment Info,Info rambursarea,
-Total Payable Interest,Dobânda totală de plată,
-Against Loan ,Împotriva împrumutului,
-Loan Interest Accrual,Dobândirea dobânzii împrumutului,
-Amounts,sume,
-Pending Principal Amount,Suma pendintei principale,
-Payable Principal Amount,Suma principală plătibilă,
-Paid Principal Amount,Suma principală plătită,
-Paid Interest Amount,Suma dobânzii plătite,
-Process Loan Interest Accrual,Procesul de dobândă de împrumut,
-Repayment Schedule Name,Numele programului de rambursare,
-Regular Payment,Plată regulată,
-Loan Closure,Închiderea împrumutului,
-Payment Details,Detalii de plata,
-Interest Payable,Dobândi de plătit,
-Amount Paid,Sumă plătită,
-Principal Amount Paid,Suma principală plătită,
-Repayment Details,Detalii de rambursare,
-Loan Repayment Detail,Detaliu rambursare împrumut,
-Loan Security Name,Numele securității împrumutului,
-Unit Of Measure,Unitate de măsură,
-Loan Security Code,Codul de securitate al împrumutului,
-Loan Security Type,Tip de securitate împrumut,
-Haircut %,Tunsori%,
-Loan  Details,Detalii despre împrumut,
-Unpledged,Unpledged,
-Pledged,gajat,
-Partially Pledged,Parțial Gajat,
-Securities,Titluri de valoare,
-Total Security Value,Valoarea totală a securității,
-Loan Security Shortfall,Deficitul de securitate al împrumutului,
-Loan ,Împrumut,
-Shortfall Time,Timpul neajunsurilor,
-America/New_York,America / New_York,
-Shortfall Amount,Suma deficiențelor,
-Security Value ,Valoarea de securitate,
-Process Loan Security Shortfall,Deficitul de securitate a împrumutului de proces,
-Loan To Value Ratio,Raportul împrumut / valoare,
-Unpledge Time,Timp de neîncărcare,
-Loan Name,Nume de împrumut,
-Rate of Interest (%) Yearly,Rata Dobânzii (%) Anual,
-Penalty Interest Rate (%) Per Day,Rata dobânzii de penalizare (%) pe zi,
-Penalty Interest Rate is levied on the pending interest amount on a daily basis in case of delayed repayment ,Rata dobânzii pentru penalități este percepută zilnic pe valoarea dobânzii în curs de rambursare întârziată,
-Grace Period in Days,Perioada de har în zile,
-No. of days from due date until which penalty won't be charged in case of delay in loan repayment,Numărul de zile de la data scadenței până la care nu se va percepe penalitatea în cazul întârzierii rambursării împrumutului,
-Pledge,Angajament,
-Post Haircut Amount,Postează cantitatea de tuns,
-Process Type,Tipul procesului,
-Update Time,Timpul de actualizare,
-Proposed Pledge,Gajă propusă,
-Total Payment,Plată totală,
-Balance Loan Amount,Soldul Suma creditului,
-Is Accrued,Este acumulat,
-Salary Slip Loan,Salariu Slip împrumut,
-Loan Repayment Entry,Intrarea rambursării împrumutului,
-Sanctioned Loan Amount,Suma de împrumut sancționată,
-Sanctioned Amount Limit,Limita sumei sancționate,
-Unpledge,Unpledge,
-Haircut,Tunsoare,
-MAT-MSH-.YYYY.-,MAT-MSH-.YYYY.-,
-Generate Schedule,Generează orar,
-Schedules,Orarele,
-Maintenance Schedule Detail,Detalii Program Mentenanta,
-Scheduled Date,Data programată,
-Actual Date,Data efectiva,
-Maintenance Schedule Item,Articol Program Mentenanță,
-Random,aleatoriu,
-No of Visits,Nu de vizite,
-MAT-MVS-.YYYY.-,MAT-MVS-.YYYY.-,
-Maintenance Date,Dată Mentenanță,
-Maintenance Time,Timp Mentenanta,
-Completion Status,Stare Finalizare,
-Partially Completed,Parțial finalizate,
-Fully Completed,Finalizat,
-Unscheduled,Neprogramat,
-Breakdown,Avarie,
-Purposes,Scopuri,
-Customer Feedback,Feedback Client,
-Maintenance Visit Purpose,Scop Vizită Mentenanță,
-Work Done,Activitatea desfășurată,
-Against Document No,Împotriva documentul nr,
-Against Document Detail No,Comparativ detaliilor documentului nr.,
-MFG-BLR-.YYYY.-,MFG-BLR-.YYYY.-,
-Order Type,Tip comandă,
-Blanket Order Item,Articol de comandă pentru plicuri,
-Ordered Quantity,Ordonat Cantitate,
-Item to be manufactured or repacked,Articol care urmează să fie fabricat sau reambalat,
-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,
-Set rate of sub-assembly item based on BOM,Viteza setată a elementului subansamblu bazat pe BOM,
-Allow Alternative Item,Permiteți un element alternativ,
-Item UOM,Articol FDM,
-Conversion Rate,Rata de conversie,
-Rate Of Materials Based On,Rate de materiale bazate pe,
-With Operations,Cu Operațiuni,
-Manage cost of operations,Gestionează costul operațiunilor,
-Transfer Material Against,Transfer material contra,
-Routing,Rutare,
-Materials,Materiale,
-Quality Inspection Required,Inspecție de calitate necesară,
-Quality Inspection Template,Model de inspecție a calității,
-Scrap,Resturi,
-Scrap Items,resturi Articole,
-Operating Cost,Costul de operare,
-Raw Material Cost,Cost Materie Primă,
-Scrap Material Cost,Cost resturi de materiale,
-Operating Cost (Company Currency),Costul de operare (Companie Moneda),
-Raw Material Cost (Company Currency),Costul materiei prime (moneda companiei),
-Scrap Material Cost(Company Currency),Cost resturi de material (companie Moneda),
-Total Cost,Cost total,
-Total Cost (Company Currency),Cost total (moneda companiei),
-Materials Required (Exploded),Materiale necesare (explodat),
-Exploded Items,Articole explozibile,
-Show in Website,Afișați pe site,
-Item Image (if not slideshow),Imagine Articol (dacă nu exista prezentare),
-Thumbnail,Miniatură,
-Website Specifications,Site-ul Specificații,
-Show Items,Afișare articole,
-Show Operations,Afișați Operații,
-Website Description,Site-ul Descriere,
-BOM Explosion Item,Explozie articol BOM,
-Qty Consumed Per Unit,Cantitate consumata pe unitatea,
-Include Item In Manufacturing,Includeți articole în fabricație,
-BOM Item,Articol BOM,
-Item operation,Operarea elementului,
-Rate & Amount,Rata și suma,
-Basic Rate (Company Currency),Rată elementară (moneda companiei),
-Scrap %,Resturi%,
-Original Item,Articolul original,
-BOM Operation,Operațiune BOM,
-Operation Time ,Timpul de funcționare,
-In minutes,În câteva minute,
-Batch Size,Mărimea lotului,
-Base Hour Rate(Company Currency),Rata de bază ore (companie Moneda),
-Operating Cost(Company Currency),Costul de operare (Companie Moneda),
-BOM Scrap Item,BOM Resturi Postul,
-Basic Amount (Company Currency),Suma de bază (Companie Moneda),
-BOM Update Tool,Instrument Actualizare BOM,
-"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.\nIt also updates latest price in all the BOMs.","Înlocuiți un BOM particular în toate celelalte BOM unde este utilizat. Acesta va înlocui vechiul link BOM, va actualiza costul și va regenera tabelul &quot;BOM Explosion Item&quot; ca pe noul BOM. Actualizează, de asemenea, ultimul preț în toate BOM-urile.",
-Replace BOM,Înlocuiește BOM,
-Current BOM,FDM curent,
-The BOM which will be replaced,BOM care va fi înlocuit,
-The new BOM after replacement,Noul BOM după înlocuirea,
-Replace,Înlocuiește,
-Update latest price in all BOMs,Actualizați cel mai recent preț în toate BOM-urile,
-BOM Website Item,Site-ul BOM Articol,
-BOM Website Operation,Site-ul BOM Funcționare,
-Operation Time,Funcționare Ora,
-PO-JOB.#####,PO-JOB. #####,
-Timing Detail,Detalii detaliate,
-Time Logs,Timp Busteni,
-Total Time in Mins,Timp total în mină,
-Operation ID,ID operațiune,
-Transferred Qty,Transferat Cantitate,
-Job Started,Job a început,
-Started Time,Timpul început,
-Current Time,Ora curentă,
-Job Card Item,Cartelă de posturi,
-Job Card Time Log,Jurnalul de timp al cărții de lucru,
-Time In Mins,Timpul în min,
-Completed Qty,Cantitate Finalizata,
-Manufacturing Settings,Setări de Fabricație,
-Raw Materials Consumption,Consumul de materii prime,
-Allow Multiple Material Consumption,Permiteți consumul mai multor materiale,
-Backflush Raw Materials Based On,Backflush Materii Prime bazat pe,
-Material Transferred for Manufacture,Material Transferat pentru fabricarea,
-Capacity Planning,Planificarea capacității,
-Disable Capacity Planning,Dezactivează planificarea capacității,
-Allow Overtime,Permiteți ore suplimentare,
-Allow Production on Holidays,Permiteţi operaţii de producție pe durata sărbătorilor,
-Capacity Planning For (Days),Planificarea capacitate de (zile),
-Default Warehouses for Production,Depozite implicite pentru producție,
-Default Work In Progress Warehouse,Implicit Lucrări în depozit Progress,
-Default Finished Goods Warehouse,Implicite terminat Marfuri Warehouse,
-Default Scrap Warehouse,Depozitul de resturi implicit,
-Overproduction Percentage For Sales Order,Procentaj de supraproducție pentru comandă de vânzări,
-Overproduction Percentage For Work Order,Procentul de supraproducție pentru comanda de lucru,
-Other Settings,alte setări,
-Update BOM Cost Automatically,Actualizați costul BOM automat,
-Material Request Plan Item,Material Cerere plan plan,
-Material Request Type,Material Cerere tip,
-Material Issue,Problema de material,
-Customer Provided,Client oferit,
-Minimum Order Quantity,Cantitatea minima pentru comanda,
-Default Workstation,Implicit Workstation,
-Production Plan,Plan de productie,
-MFG-PP-.YYYY.-,MFG-PP-.YYYY.-,
-Get Items From,Obține elemente din,
-Get Sales Orders,Obține comenzile de vânzări,
-Material Request Detail,Detalii privind solicitarea materialului,
-Get Material Request,Material Cerere obțineți,
-Material Requests,Cereri de materiale,
-Get Items For Work Order,Obțineți comenzi pentru lucru,
-Material Request Planning,Planificarea solicitărilor materiale,
-Include Non Stock Items,Includeți articole din stoc,
-Include Subcontracted Items,Includeți articole subcontractate,
-Ignore Existing Projected Quantity,Ignorați cantitatea proiectată existentă,
-"To know more about projected quantity, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">click here</a>.","Pentru a afla mai multe despre cantitatea proiectată, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">faceți clic aici</a> .",
-Download Required Materials,Descărcați materialele necesare,
-Get Raw Materials For Production,Obțineți materii prime pentru producție,
-Total Planned Qty,Cantitatea totală planificată,
-Total Produced Qty,Cantitate total produsă,
-Material Requested,Material solicitat,
-Production Plan Item,Planul de producție Articol,
-Make Work Order for Sub Assembly Items,Realizați comanda de lucru pentru articolele de subansamblare,
-"If enabled, system will create the work order for the exploded items against which BOM is available.","Dacă este activat, sistemul va crea ordinea de lucru pentru elementele explodate pentru care este disponibilă BOM.",
-Planned Start Date,Start data planificată,
-Quantity and Description,Cantitate și descriere,
-material_request_item,material_request_item,
-Product Bundle Item,Produs Bundle Postul,
-Production Plan Material Request,Producția Plan de material Cerere,
-Production Plan Sales Order,Planul de producție comandă de vânzări,
-Sales Order Date,Comandă de vânzări Data,
-Routing Name,Numele de rutare,
-MFG-WO-.YYYY.-,MFG-WO-.YYYY.-,
-Item To Manufacture,Articol pentru Fabricare,
-Material Transferred for Manufacturing,Materii Transferate pentru fabricarea,
-Manufactured Qty,Cantitate Produsă,
-Use Multi-Level BOM,Utilizarea Multi-Level BOM,
-Plan material for sub-assemblies,Material Plan de subansambluri,
-Skip Material Transfer to WIP Warehouse,Treceți transferul de materiale la WIP Warehouse,
-Check if material transfer entry is not required,Verificați dacă nu este necesară introducerea transferului de materiale,
-Backflush Raw Materials From Work-in-Progress Warehouse,Materii prime de tip backflush din depozitul &quot;work-in-progress&quot;,
-Update Consumed Material Cost In Project,Actualizați costurile materialelor consumate în proiect,
-Warehouses,Depozite,
-This is a location where raw materials are available.,Acesta este un loc unde materiile prime sunt disponibile.,
-Work-in-Progress Warehouse,Depozit Lucru-în-Progres,
-This is a location where operations are executed.,Aceasta este o locație în care se execută operațiuni.,
-This is a location where final product stored.,Aceasta este o locație în care este depozitat produsul final.,
-Scrap Warehouse,Depozit fier vechi,
-This is a location where scraped materials are stored.,Aceasta este o locație în care sunt depozitate materiale razuite.,
-Required Items,Articole cerute,
-Actual Start Date,Dată Efectivă de Început,
-Planned End Date,Planificate Data de încheiere,
-Actual End Date,Data efectiva de finalizare,
-Operation Cost,Funcționare cost,
-Planned Operating Cost,Planificate cost de operare,
-Actual Operating Cost,Cost efectiv de operare,
-Additional Operating Cost,Costuri de operare adiţionale,
-Total Operating Cost,Cost total de operare,
-Manufacture against Material Request,Fabricare împotriva Cerere Material,
-Work Order Item,Postul de comandă de lucru,
-Available Qty at Source Warehouse,Cantitate disponibilă la Warehouse sursă,
-Available Qty at WIP Warehouse,Cantitate disponibilă la WIP Warehouse,
-Work Order Operation,Comandă de comandă de lucru,
-Operation Description,Operație Descriere,
-Operation completed for how many finished goods?,Funcționare completat de cât de multe bunuri finite?,
-Work in Progress,Lucrări în curs,
-Estimated Time and Cost,Timpul estimat și cost,
-Planned Start Time,Planificate Ora de începere,
-Planned End Time,Planificate End Time,
-in Minutes,In cateva minute,
-Actual Time and Cost,Timp și cost efective,
-Actual Start Time,Timpul efectiv de începere,
-Actual End Time,Timp efectiv de sfârşit,
-Updated via 'Time Log',"Actualizat prin ""Ora Log""",
-Actual Operation Time,Timp efectiv de funcționare,
-in Minutes\nUpdated via 'Time Log',"în procesul-verbal \n Actualizat prin ""Ora Log""",
-(Hour Rate / 60) * Actual Operation Time,(Tarif orar / 60) * Timp efectiv de operare,
-Workstation Name,Stație de lucru Nume,
-Production Capacity,Capacitatea de producție,
-Operating Costs,Costuri de operare,
-Electricity Cost,Cost energie electrică,
-per hour,pe oră,
-Consumable Cost,Cost Consumabile,
-Rent Cost,Cost Chirie,
-Wages,Salarizare,
-Wages per hour,Salarii pe oră,
-Net Hour Rate,Net Rata de ore,
-Workstation Working Hour,Statie de lucru de ore de lucru,
-Certification Application,Cerere de certificare,
-Name of Applicant,Numele aplicantului,
-Certification Status,Stare Certificare,
-Yet to appear,"Totuși, să apară",
-Certified,Certificat,
-Not Certified,Nu este certificată,
-USD,USD,
-INR,INR,
-Certified Consultant,Consultant Certificat,
-Name of Consultant,Numele consultantului,
-Certification Validity,Valabilitatea Certificare,
-Discuss ID,Discutați ID-ul,
-GitHub ID,ID-ul GitHub,
-Non Profit Manager,Manager non-profit,
-Chapter Head,Capitolul Cap,
-Meetup Embed HTML,Meetup Embed HTML,
-chapters/chapter_name\nleave blank automatically set after saving chapter.,capitole / nume_capitale lasă setul automat să fie setat automat după salvarea capitolului.,
-Chapter Members,Capitolul Membri,
-Members,Membrii,
-Chapter Member,Membru de capitol,
-Website URL,Website URL,
-Leave Reason,Lăsați rațiunea,
-Donor Name,Numele donatorului,
-Donor Type,Tipul donatorului,
-Withdrawn,retrasă,
-Grant Application Details ,Detalii privind cererile de finanțare,
-Grant Description,Descrierea granturilor,
-Requested Amount,Suma solicitată,
-Has any past Grant Record,Are vreun dosar Grant trecut,
-Show on Website,Afișați pe site,
-Assessment  Mark (Out of 10),Marca de evaluare (din 10),
-Assessment  Manager,Manager de evaluare,
-Email Notification Sent,Trimiterea notificării prin e-mail,
-NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-,
-Membership Expiry Date,Data expirării membrilor,
-Razorpay Details,Detalii Razorpay,
-Subscription ID,ID-ul abonamentului,
-Customer ID,Număr de înregistrare client,
-Subscription Activated,Abonament activat,
-Subscription Start ,Începere abonament,
-Subscription End,Încheierea abonamentului,
-Non Profit Member,Membru non-profit,
-Membership Status,Statutul de membru,
-Member Since,Membru din,
-Payment ID,ID de plată,
-Membership Settings,Setări de membru,
-Enable RazorPay For Memberships,Activați RazorPay pentru calitatea de membru,
-RazorPay Settings,Setări RazorPay,
-Billing Cycle,Ciclu de facturare,
-Billing Frequency,Frecvența de facturare,
-"The number of billing cycles for which the customer should be charged. For example, if a customer is buying a 1-year membership that should be billed on a monthly basis, this value should be 12.","Numărul de cicluri de facturare pentru care ar trebui să fie taxat clientul. De exemplu, dacă un client cumpără un abonament de 1 an care ar trebui să fie facturat lunar, această valoare ar trebui să fie 12.",
-Razorpay Plan ID,ID-ul planului Razorpay,
-Volunteer Name,Nume de voluntar,
-Volunteer Type,Tipul de voluntari,
-Availability and Skills,Disponibilitate și abilități,
-Availability,Disponibilitate,
-Weekends,Weekend-uri,
-Availability Timeslot,Disponibilitatea Timeslot,
-Morning,Dimineaţă,
-Afternoon,Dupa amiaza,
-Evening,Seară,
-Anytime,Oricând,
-Volunteer Skills,Abilități de voluntariat,
-Volunteer Skill,Abilități de voluntariat,
-Homepage,Pagina Principală,
-Hero Section Based On,Secția Eroilor Bazată pe,
-Homepage Section,Secțiunea Prima pagină,
-Hero Section,Secția Eroilor,
-Tag Line,Eticheta linie,
-Company Tagline for website homepage,Firma Tagline pentru pagina de start site,
-Company Description for website homepage,Descriere companie pentru pagina de start site,
-Homepage Slideshow,Prezentare Slideshow a paginii de start,
-"URL for ""All Products""",URL-ul pentru &quot;Toate produsele&quot;,
-Products to be shown on website homepage,Produsele care urmează să fie afișate pe pagina de pornire site,
-Homepage Featured Product,Pagina de intrare de produse recomandate,
-route,traseu,
-Section Based On,Secțiune bazată pe,
-Section Cards,Cărți de secțiune,
-Number of Columns,Numar de coloane,
-Number of columns for this section. 3 cards will be shown per row if you select 3 columns.,Numărul de coloane pentru această secțiune. 3 cărți vor fi afișate pe rând dacă selectați 3 coloane.,
-Section HTML,Secțiunea HTML,
-Use this field to render any custom HTML in the section.,Utilizați acest câmp pentru a reda orice HTML personalizat în secțiune.,
-Section Order,Comanda secțiunii,
-"Order in which sections should appear. 0 is first, 1 is second and so on.","Ordinea în care ar trebui să apară secțiunile. 0 este primul, 1 este al doilea și așa mai departe.",
-Homepage Section Card,Pagina de secțiune Card de secțiune,
-Subtitle,Subtitlu,
-Products Settings,produse Setări,
-Home Page is Products,Pagina Principală este Produse,
-"If checked, the Home page will be the default Item Group for the website","Dacă este bifată, pagina de pornire va fi implicit postul Grupului pentru site-ul web",
-Show Availability Status,Afișați starea de disponibilitate,
-Product Page,Pagina produsului,
-Products per Page,Produse pe Pagină,
-Enable Field Filters,Activați filtrele de câmp,
-Item Fields,Câmpurile articolului,
-Enable Attribute Filters,Activați filtrele de atribute,
-Attributes,Atribute,
-Hide Variants,Ascundeți variantele,
-Website Attribute,Atribut site web,
-Attribute,Atribute,
-Website Filter Field,Câmpul de filtrare a site-ului web,
-Activity Cost,Cost activitate,
-Billing Rate,Tarif de facturare,
-Costing Rate,Costing Rate,
-title,titlu,
-Projects User,Utilizator Proiecte,
-Default Costing Rate,Rată Cost Implicit,
-Default Billing Rate,Tarif de Facturare Implicit,
-Dependent Task,Sarcina dependent,
-Project Type,Tip de proiect,
-% Complete Method,% Metoda completă,
-Task Completion,sarcina Finalizarea,
-Task Progress,Progresul sarcină,
-% Completed,% Finalizat,
-From Template,Din șablon,
-Project will be accessible on the website to these users,Proiectul va fi accesibil pe site-ul acestor utilizatori,
-Copied From,Copiat de la,
-Start and End Dates,Începere și de încheiere Date,
-Actual Time (in Hours),Ora reală (în ore),
-Costing and Billing,Calculație a cheltuielilor și veniturilor,
-Total Costing Amount (via Timesheets),Suma totală a costurilor (prin intermediul foilor de pontaj),
-Total Expense Claim (via Expense Claims),Revendicarea Total cheltuieli (prin formularele de decont),
-Total Purchase Cost (via Purchase Invoice),Cost total de achiziție (prin cumparare factură),
-Total Sales Amount (via Sales Order),Suma totală a vânzărilor (prin comandă de vânzări),
-Total Billable Amount (via Timesheets),Sumă totală facturată (prin intermediul foilor de pontaj),
-Total Billed Amount (via Sales Invoices),Suma facturată totală (prin facturi de vânzare),
-Total Consumed Material Cost  (via Stock Entry),Costul total al materialelor consumate (prin intrarea în stoc),
-Gross Margin,Marja Brută,
-Gross Margin %,Marja Bruta%,
-Monitor Progress,Monitorizați progresul,
-Collect Progress,Collect Progress,
-Frequency To Collect Progress,Frecventa de colectare a progresului,
-Twice Daily,De doua ori pe zi,
-First Email,Primul e-mail,
-Second Email,Al doilea e-mail,
-Time to send,Este timpul să trimiteți,
-Day to Send,Zi de Trimis,
-Message will be sent to the users to get their status on the Project,Mesajul va fi trimis utilizatorilor pentru a obține starea lor în Proiect,
-Projects Manager,Manager Proiecte,
-Project Template,Model de proiect,
-Project Template Task,Sarcina șablonului de proiect,
-Begin On (Days),Începeți (zile),
-Duration (Days),Durata (zile),
-Project Update,Actualizarea proiectului,
-Project User,utilizator proiect,
-View attachments,Vizualizați atașamentele,
-Projects Settings,Setări pentru proiecte,
-Ignore Workstation Time Overlap,Ignorați suprapunerea timpului de lucru al stației,
-Ignore User Time Overlap,Ignorați timpul suprapunerii utilizatorului,
-Ignore Employee Time Overlap,Ignorați suprapunerea timpului angajatului,
-Weight,Greutate,
-Parent Task,Activitatea părintească,
-Timeline,Cronologie,
-Expected Time (in hours),Timp de așteptat (în ore),
-% Progress,% Progres,
-Is Milestone,Este Milestone,
-Task Description,Descrierea sarcinii,
-Dependencies,dependenţe,
-Dependent Tasks,Sarcini dependente,
-Depends on Tasks,Depinde de Sarcini,
-Actual Start Date (via Time Sheet),Data Efectiva de Început (prin Pontaj),
-Actual Time (in hours),Timpul efectiv (în ore),
-Actual End Date (via Time Sheet),Dată de Încheiere Efectivă (prin Pontaj),
-Total Costing Amount (via Time Sheet),Suma totală de calculație a costurilor (prin timp Sheet),
-Total Expense Claim (via Expense Claim),Revendicarea Total cheltuieli (prin cheltuieli revendicarea),
-Total Billing Amount (via Time Sheet),Suma totală de facturare (prin timp Sheet),
-Review Date,Data Comentariului,
-Closing Date,Data de Inchidere,
-Task Depends On,Sarcina Depinde,
-Task Type,Tipul sarcinii,
-TS-.YYYY.-,TS-.YYYY.-,
-Employee Detail,Detaliu angajat,
-Billing Details,Detalii de facturare,
-Total Billable Hours,Numărul total de ore facturabile,
-Total Billed Hours,Numărul total de ore facturate,
-Total Costing Amount,Suma totală Costing,
-Total Billable Amount,Suma totală Taxabil,
-Total Billed Amount,Suma totală Billed,
-% Amount Billed,% Suma facturata,
-Hrs,ore,
-Costing Amount,Costing Suma,
-Corrective/Preventive,Corectivă / preventivă,
-Corrective,corectiv,
-Preventive,Preventiv,
-Resolution,Rezoluție,
-Resolutions,rezoluţiile,
-Quality Action Resolution,Rezolvare acțiuni de calitate,
-Quality Feedback Parameter,Parametru de feedback al calității,
-Quality Feedback Template Parameter,Parametrul șablonului de feedback al calității,
-Quality Goal,Obiectivul de calitate,
-Monitoring Frequency,Frecvența de monitorizare,
-Weekday,zi de lucru,
-Objectives,Obiective,
-Quality Goal Objective,Obiectivul calității,
-Objective,Obiectiv,
-Agenda,Agendă,
-Minutes,Minute,
-Quality Meeting Agenda,Agenda întâlnirii de calitate,
-Quality Meeting Minutes,Proces-verbal de calitate al întâlnirii,
-Minute,Minut,
-Parent Procedure,Procedura părinților,
-Processes,procese,
-Quality Procedure Process,Procesul procedurii de calitate,
-Process Description,Descrierea procesului,
-Link existing Quality Procedure.,Conectați procedura de calitate existentă.,
-Additional Information,informatii suplimentare,
-Quality Review Objective,Obiectivul revizuirii calității,
-DATEV Settings,Setări DATEV,
-Regional,Regional,
-Consultant ID,ID-ul consultantului,
-GST HSN Code,Codul GST HSN,
-HSN Code,Codul HSN,
-GST Settings,Setări GST,
-GST Summary,Rezumatul GST,
-GSTIN Email Sent On,GSTIN Email trimis pe,
-GST Accounts,Conturi GST,
-B2C Limit,Limita B2C,
-Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Setați valoarea facturii pentru B2C. B2CL și B2CS calculate pe baza acestei valori de facturare.,
-GSTR 3B Report,Raportul GSTR 3B,
-January,ianuarie,
-February,februarie,
-March,Martie,
-April,Aprilie,
-May,Mai,
-June,iunie,
-July,iulie,
-August,August,
-September,Septembrie,
-October,octombrie,
-November,noiembrie,
-December,decembrie,
-JSON Output,Ieșire JSON,
-Invoices with no Place Of Supply,Facturi fără loc de furnizare,
-Import Supplier Invoice,Import factură furnizor,
-Invoice Series,Seria facturilor,
-Upload XML Invoices,Încărcați facturile XML,
-Zip File,Fișier Zip,
-Import Invoices,Importul facturilor,
-Click on Import Invoices button once the zip file has been attached to the document. Any errors related to processing will be shown in the Error Log.,Faceți clic pe butonul Import facturi după ce fișierul zip a fost atașat la document. Orice erori legate de procesare vor fi afișate în Jurnalul de erori.,
-Lower Deduction Certificate,Certificat de deducere inferior,
-Certificate Details,Detalii certificat,
-194A,194A,
-194C,194C,
-194D,194D,
-194H,194H,
-194I,194I,
-194J,194J,
-194LA,194LA,
-194LBB,194LBB,
-194LBC,194LBC,
-Certificate No,număr de certificat,
-Deductee Details,Detalii despre deducere,
-PAN No,PAN nr,
-Validity Details,Detalii de valabilitate,
-Rate Of TDS As Per Certificate,Rata TDS conform certificatului,
-Certificate Limit,Limita certificatului,
-Invoice Series Prefix,Prefixul seriei de facturi,
-Active Menu,Meniul activ,
-Restaurant Menu,Meniu Restaurant,
-Price List (Auto created),Listă Prețuri (creată automat),
-Restaurant Manager,Manager Restaurant,
-Restaurant Menu Item,Articol Meniu Restaurant,
-Restaurant Order Entry,Intrare comandă de restaurant,
-Restaurant Table,Masă Restaurant,
-Click Enter To Add,Faceți clic pe Enter to Add,
-Last Sales Invoice,Ultima factură de vânzare,
-Current Order,Comanda actuală,
-Restaurant Order Entry Item,Articol de intrare pentru comandă pentru restaurant,
-Served,servit,
-Restaurant Reservation,Rezervare la restaurant,
-Waitlisted,waitlisted,
-No Show,Neprezentare,
-No of People,Nr de oameni,
-Reservation Time,Timp de rezervare,
-Reservation End Time,Timp de terminare a rezervării,
-No of Seats,Numărul de scaune,
-Minimum Seating,Scaunele minime,
-"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment. ","Păstra Tractor de campanii de vanzari. Țineți evidența de afaceri, Cotațiile, comandă de vânzări, etc de la Campanii pentru a evalua Return on Investment.",
-SAL-CAM-.YYYY.-,SAL-CAM-.YYYY.-,
-Campaign Schedules,Programele campaniei,
-Buyer of Goods and Services.,Cumpărător de produse și servicii.,
-CUST-.YYYY.-,CUST-.YYYY.-,
-Default Company Bank Account,Cont bancar al companiei implicite,
-From Lead,Din Pistă,
-Account Manager,Manager Conturi,
-Allow Sales Invoice Creation Without Sales Order,Permiteți crearea facturilor de vânzare fără comandă de vânzare,
-Allow Sales Invoice Creation Without Delivery Note,Permiteți crearea facturilor de vânzare fără notă de livrare,
-Default Price List,Lista de Prețuri Implicita,
-Primary Address and Contact Detail,Adresa principală și detaliile de contact,
-"Select, to make the customer searchable with these fields","Selectați, pentru a face ca clientul să poată fi căutat în aceste câmpuri",
-Customer Primary Contact,Contact primar client,
-"Reselect, if the chosen contact is edited after save",Resetați dacă contactul ales este editat după salvare,
-Customer Primary Address,Adresa primară a clientului,
-"Reselect, if the chosen address is edited after save",Resetați dacă adresa editată este editată după salvare,
-Primary Address,adresa primara,
-Mention if non-standard receivable account,Mentionati daca non-standard cont de primit,
-Credit Limit and Payment Terms,Limita de credit și termenii de plată,
-Additional information regarding the customer.,Informații suplimentare cu privire la client.,
-Sales Partner and Commission,Partener de vânzări și a Comisiei,
-Commission Rate,Rata de Comision,
-Sales Team Details,Detalii de vânzări Echipa,
-Customer POS id,ID POS client,
-Customer Credit Limit,Limita de creditare a clienților,
-Bypass Credit Limit Check at Sales Order,Treceți la verificarea limită de credit la Comandă de vânzări,
-Industry Type,Industrie Tip,
-MAT-INS-.YYYY.-,MAT-INS-.YYYY.-,
-Installation Date,Data de instalare,
-Installation Time,Timp de instalare,
-Installation Note Item,Instalare Notă Postul,
-Installed Qty,Instalat Cantitate,
-Lead Source,Sursa de plumb,
-Period Start Date,Data de începere a perioadei,
-Period End Date,Perioada de sfârșit a perioadei,
-Cashier,Casier,
-Difference,Diferență,
-Modes of Payment,Moduri de plată,
-Linked Invoices,Linked Factures,
-POS Closing Voucher Details,Detalii Voucher de închidere POS,
-Collected Amount,Suma colectată,
-Expected Amount,Suma așteptată,
-POS Closing Voucher Invoices,Facturi pentru voucherele de închidere de la POS,
-Quantity of Items,Cantitatea de articole,
-"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. \n\nThe package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".\n\nFor Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.\n\nNote: BOM = Bill of Materials","Grup agregat de articole ** ** în alt articol ** **. Acest lucru este util dacă gruparea de anumite elemente ** ** într-un pachet și să mențină un bilanț al ambalate ** ** Elemente și nu agregate ** Postul **. Pachetul ** Postul ** va avea &quot;Este Piesa&quot; ca &quot;No&quot; și &quot;Este punctul de vânzare&quot;, ca &quot;Da&quot;. De exemplu: dacă sunteți de vânzare Laptop-uri și Rucsacuri separat și au un preț special dacă clientul cumpără atât, atunci laptop + rucsac va fi un nou Bundle produs Postul. Notă: BOM = Bill de materiale",
-Parent Item,Părinte Articol,
-List items that form the package.,Listeaza articole care formează pachetul.,
-SAL-QTN-.YYYY.-,SAL-QTN-.YYYY.-,
-Quotation To,Ofertă Pentru a,
-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 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,
-Additional Discount and Coupon Code,Cod suplimentar de reducere și cupon,
-Referral Sales Partner,Partener de vânzări de recomandări,
-In Words will be visible once you save the Quotation.,În cuvinte va fi vizibil după ce salvați citat.,
-Term Details,Detalii pe termen,
-Quotation Item,Ofertă Articol,
-Against Doctype,Comparativ tipului documentului,
-Against Docname,Comparativ denumirii documentului,
-Additional Notes,Note Aditionale,
-SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-,
-Skip Delivery Note,Salt nota de livrare,
-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.,
-Track this Sales Order against any Project,Urmareste acest Ordin de vânzări față de orice proiect,
-Billing and Delivery Status,Facturare și stare livrare,
-Not Delivered,Nu Pronunțată,
-Fully Delivered,Livrat complet,
-Partly Delivered,Parțial livrate,
-Not Applicable,Nu se aplică,
-%  Delivered,% Livrat,
-% of materials delivered against this Sales Order,% de materiale livrate versus aceasta Comanda,
-% of materials billed against this Sales Order,% de materiale facturate versus această Comandă de Vânzări,
-Not Billed,Nu Taxat,
-Fully Billed,Complet Taxat,
-Partly Billed,Parțial Taxat,
-Ensure Delivery Based on Produced Serial No,Asigurați livrarea pe baza numărului de serie produs,
-Supplier delivers to Customer,Furnizor livrează la client,
-Delivery Warehouse,Depozit de livrare,
-Planned Quantity,Planificate Cantitate,
-For Production,Pentru Producție,
-Work Order Qty,Numărul comenzilor de lucru,
-Produced Quantity,Produs Cantitate,
-Used for Production Plan,Folosit pentru Planul de producție,
-Sales Partner Type,Tip de partener de vânzări,
-Contact No.,Nr. Persoana de Contact,
-Contribution (%),Contribuție (%),
-Contribution to Net Total,Contribuție la Total Net,
-Selling Settings,Setări Vânzare,
-Settings for Selling Module,Setări pentru vânzare Modulul,
-Customer Naming By,Numire Client de catre,
-Campaign Naming By,Campanie denumita de,
-Default Customer Group,Grup Clienți Implicit,
-Default Territory,Teritoriu Implicit,
-Close Opportunity After Days,Închide oportunitate După zile,
-Default Quotation Validity Days,Valabilitatea zilnică a cotațiilor,
-Sales Update Frequency,Frecventa actualizarii vanzarilor,
-Each Transaction,Fiecare tranzacție,
-SMS Center,SMS Center,
-Send To,Trimite la,
-All Contact,Toate contactele,
-All Customer Contact,Toate contactele clienților,
-All Supplier Contact,Toate contactele furnizorului,
-All Sales Partner Contact,Toate contactele partenerului de vânzări,
-All Lead (Open),Toate Pistele (Deschise),
-All Employee (Active),Toți angajații (activi),
-All Sales Person,Toate persoanele de vânzăril,
-Create Receiver List,Creare Lista Recipienti,
-Receiver List,Receptor Lista,
-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,
-Total Characters,Total de caractere,
-Total Message(s),Total mesaj(e),
-Authorization Control,Control de autorizare,
-Authorization Rule,Regulă de autorizare,
-Average Discount,Discount mediiu,
-Customerwise Discount,Reducere Client,
-Itemwise Discount,Reducere Articol-Avizat,
-Customer or Item,Client sau un element,
-Customer / Item Name,Client / Denumire articol,
-Authorized Value,Valoarea autorizată,
-Applicable To (Role),Aplicabil pentru (rol),
-Applicable To (Employee),Aplicabil pentru (angajat),
-Applicable To (User),Aplicabil pentru (utilizator),
-Applicable To (Designation),Aplicabil pentru (destinaţie),
-Approving Role (above authorized value),Aprobarea Rol (mai mare decât valoarea autorizată),
-Approving User  (above authorized value),Aprobarea utilizator (mai mare decât valoarea autorizată),
-Brand Defaults,Valorile implicite ale mărcii,
-Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Entitate Juridică / Filială cu o Diagramă de Conturi separată aparținând Organizației.,
-Change Abbreviation,Schimbă Abreviere,
-Parent Company,Compania mamă,
-Default Values,Valori implicite,
-Default Holiday List,Implicit Listă de vacanță,
-Default Selling Terms,Condiții de vânzare implicite,
-Default Buying Terms,Condiții de cumpărare implicite,
-Create Chart Of Accounts Based On,"Creează Diagramă de Conturi, Bazată pe",
-Standard Template,Format standard,
-Existing Company,Companie existentă,
-Chart Of Accounts Template,Diagramă de Șablon Conturi,
-Existing Company ,companie existentă,
-Date of Establishment,Data Înființării,
-Sales Settings,Setări de vânzări,
-Monthly Sales Target,Vânzări lunare,
-Sales Monthly History,Istoric Lunar de Vânzări,
-Transactions Annual History,Istoricul tranzacțiilor anuale,
-Total Monthly Sales,Vânzări totale lunare,
-Default Cash Account,Cont de Numerar Implicit,
-Default Receivable Account,Implicit cont de încasat,
-Round Off Cost Center,Rotunji cost Center,
-Discount Allowed Account,Cont permis de reducere,
-Discount Received Account,Reducerea contului primit,
-Exchange Gain / Loss Account,Cont Cheltuiala / Venit din diferente de curs valutar,
-Unrealized Exchange Gain/Loss Account,Contul de câștig / pierdere din contul nerealizat,
-Allow Account Creation Against Child Company,Permite crearea de cont împotriva companiei pentru copii,
-Default Payable Account,Implicit cont furnizori,
-Default Employee Advance Account,Implicit Cont Advance Advance Employee,
-Default Cost of Goods Sold Account,Cont Implicit Cost Bunuri Vândute,
-Default Income Account,Contul Venituri Implicit,
-Default Deferred Revenue Account,Implicit Contul cu venituri amânate,
-Default Deferred Expense Account,Implicit contul amânat de cheltuieli,
-Default Payroll Payable Account,Implicit Salarizare cont de plati,
-Default Expense Claim Payable Account,Cont Predefinit Solicitare Cheltuială Achitată,
-Stock Settings,Setări stoc,
-Enable Perpetual Inventory,Activați inventarul perpetuu,
-Default Inventory Account,Contul de inventar implicit,
-Stock Adjustment Account,Cont Ajustarea stoc,
-Fixed Asset Depreciation Settings,Setări de amortizare fixă Activ,
-Series for Asset Depreciation Entry (Journal Entry),Seria pentru intrarea în amortizarea activelor (intrare în jurnal),
-Gain/Loss Account on Asset Disposal,Cont câștig / Pierdere de eliminare a activelor,
-Asset Depreciation Cost Center,Centru de cost Amortizare Activ,
-Budget Detail,Detaliu buget,
-Exception Budget Approver Role,Rolul de abordare a bugetului de excepție,
-Company Info,Informaţii Companie,
-For reference only.,Numai Pentru referință.,
-Company Logo,Logoul companiei,
-Date of Incorporation,Data Încorporării,
-Date of Commencement,Data începerii,
-Phone No,Nu telefon,
-Company Description,Descrierea Companiei,
-Registration Details,Detalii de Înregistrare,
-Company registration numbers for your reference. Tax numbers etc.,Numerele de înregistrare companie pentru referință. Numerele fiscale etc,
-Delete Company Transactions,Ștergeți Tranzacții de Firma,
-Currency Exchange,Curs Valutar,
-Specify Exchange Rate to convert one currency into another,Precizați Rata de schimb a converti o monedă în alta,
-From Currency,Din moneda,
-To Currency,Pentru a valutar,
-For Buying,Pentru cumparare,
-For Selling,Pentru vânzări,
-Customer Group Name,Nume Group Client,
-Parent Customer Group,Părinte Grup Clienți,
-Only leaf nodes are allowed in transaction,Numai noduri frunze sunt permise în tranzacție,
-Mention if non-standard receivable account applicable,Menționa dacă non-standard de cont primit aplicabil,
-Credit Limits,Limitele de credit,
-Email Digest,Email Digest,
-Send regular summary reports via Email.,Trimite rapoarte de sinteză periodice prin e-mail.,
-Email Digest Settings,Setari Email Digest,
-How frequently?,Cât de frecvent?,
-Next email will be sent on:,Următorul email va fi trimis la:,
-Note: Email will not be sent to disabled users,Notă: Adresa de email nu va fi trimis la utilizatorii cu handicap,
-Profit & Loss,Pierderea profitului,
-New Income,noul venit,
-New Expenses,Cheltuieli noi,
-Annual Income,Venit anual,
-Annual Expenses,Cheltuielile anuale,
-Bank Balance,Banca Balance,
-Bank Credit Balance,Soldul creditului bancar,
-Receivables,Creanțe,
-Payables,Datorii,
-Sales Orders to Bill,Comenzi de vânzare către Bill,
-Purchase Orders to Bill,Achiziționați comenzi către Bill,
-New Sales Orders,Noi comenzi de vânzări,
-New Purchase Orders,Noi comenzi de aprovizionare,
-Sales Orders to Deliver,Comenzi de livrare pentru livrare,
-Purchase Orders to Receive,Comenzi de cumpărare pentru a primi,
-New Purchase Invoice,Factură de achiziție nouă,
-New Quotations,Noi Oferte,
-Open Quotations,Oferte deschise,
-Open Issues,Probleme deschise,
-Open Projects,Proiecte deschise,
-Purchase Orders Items Overdue,Elementele comenzilor de cumpărare sunt restante,
-Upcoming Calendar Events,Evenimente calendaristice viitoare,
-Open To Do,Deschis de făcut,
-Add Quote,Adaugă Citat,
-Global Defaults,Valori Implicite Globale,
-Default Company,Companie Implicită,
-Current Fiscal Year,An Fiscal Curent,
-Default Distance Unit,Unitatea de distanță standard,
-Hide Currency Symbol,Ascunde simbol moneda,
-Do not show any symbol like $ etc next to currencies.,Nu afisa nici un simbol de genul $ etc alături de valute.,
-"If disable, 'Rounded Total' field will not be visible in any transaction","Dacă este dezactivat, câmpul 'Total Rotunjit' nu va fi vizibil in nici o tranzacție",
-Disable In Words,Nu fi de acord în cuvinte,
-"If disable, 'In Words' field will not be visible in any transaction","În cazul în care dezactivați, &quot;în cuvinte&quot; câmp nu vor fi vizibile în orice tranzacție",
-Item Classification,Postul Clasificare,
-General Settings,Setări generale,
-Item Group Name,Denumire Grup Articol,
-Parent Item Group,Părinte Grupa de articole,
-Item Group Defaults,Setări implicite pentru grupul de articole,
-Item Tax,Taxa Articol,
-Check this if you want to show in website,Bifati dacă doriți să fie afisat în site,
-Show this slideshow at the top of the page,Arată această prezentare în partea de sus a paginii,
-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.",
-Set prefix for numbering series on your transactions,Set prefix pentru seria de numerotare pe tranzacțiile dvs.,
-Setup Series,Seria de configurare,
-Select Transaction,Selectați Transaction,
-Help HTML,Ajutor HTML,
-Series List for this Transaction,Lista de serie pentru această tranzacție,
-User must always select,Utilizatorul trebuie să selecteze întotdeauna,
-Check this if you want to force the user to select a series before saving. There will be no default if you check this.,"Bifati dacă doriți sa fortati utilizatorul să selecteze o serie înainte de a salva. Nu va exista nici o valoare implicita dacă se bifeaza aici.""",
-Update Series,Actualizare Series,
-Change the starting / current sequence number of an existing series.,Schimbați secventa de numar de inceput / curent a unei serii existente.,
-Prefix,Prefix,
-Current Value,Valoare curenta,
-This is the number of the last created transaction with this prefix,Acesta este numărul ultimei tranzacții create cu acest prefix,
-Update Series Number,Actualizare Serii Număr,
-Quotation Lost Reason,Ofertă pierdut rațiunea,
-A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Un distribuitor terță parte / dealer / agent comisionar / afiliat / re-vânzător care vinde produsele companiei pentru un comision.,
-Sales Partner Name,Numele Partner Sales,
-Partner Type,Tip partener,
-Address & Contacts,Adresă şi contacte,
-Address Desc,Adresă Desc,
-Contact Desc,Persoana de Contact Desc,
-Sales Partner Target,Vânzări Partner țintă,
-Targets,Obiective,
-Show In Website,Arata pe site-ul,
-Referral Code,Codul de recomandare,
-To Track inbound purchase,Pentru a urmări achiziția de intrare,
-Logo,Logo,
-Partner website,site-ul partenerului,
-All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,Toate tranzacțiile de vânzări pot fi etichetate comparativ mai multor **Persoane de vânzări** pentru ca dvs. sa puteţi configura și monitoriza obiective.,
-Name and Employee ID,Nume și ID angajat,
-Sales Person Name,Sales Person Nume,
-Parent Sales Person,Mamă Sales Person,
-Select company name first.,Selectați numele companiei în primul rând.,
-Sales Person Targets,Ținte Persoane Vânzări,
-Set targets Item Group-wise for this Sales Person.,Stabilească obiective Articol Grupa-înțelept pentru această persoană de vânzări.,
-Supplier Group Name,Numele grupului de furnizori,
-Parent Supplier Group,Grupul furnizorilor-mamă,
-Target Detail,Țintă Detaliu,
-Target Qty,Țintă Cantitate,
-Target  Amount,Suma țintă,
-Target Distribution,Țintă Distribuție,
-"Standard Terms and Conditions that can be added to Sales and Purchases.\n\nExamples:\n\n1. Validity of the offer.\n1. Payment Terms (In Advance, On Credit, part advance etc).\n1. What is extra (or payable by the Customer).\n1. Safety / usage warning.\n1. Warranty if any.\n1. Returns Policy.\n1. Terms of shipping, if applicable.\n1. Ways of addressing disputes, indemnity, liability, etc.\n1. Address and Contact of your Company.","Termeni și Condiții care pot fi adăugate la vânzările și achizițiile standard.\n\n Exemple: \n\n 1. Perioada de valabilitate a ofertei.\n 1. Conditii de plata (in avans, pe credit, parte în avans etc.).\n 1. Ce este în plus (sau de plătit de către Client).\n 1. Siguranța / avertizare utilizare.\n 1. Garantie dacă este cazul.\n 1. Politica de Returnare.\n 1. Condiții de transport maritim, dacă este cazul.\n 1. Modalitati de litigii de adresare, indemnizație, răspunderea, etc. \n 1. Adresa și de contact ale companiei.",
-Applicable Modules,Module aplicabile,
-Terms and Conditions Help,Termeni și Condiții Ajutor,
-Classification of Customers by region,Clasificarea clienți în funcție de regiune,
-Territory Name,Teritoriului Denumire,
-Parent Territory,Teritoriul părinte,
-Territory Manager,Teritoriu Director,
-For reference,Pentru referință,
-Territory Targets,Obiective Territory,
-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.",
-UOM Name,Numele UOM,
-Check this to disallow fractions. (for Nos),Bifati pentru a nu permite fracțiuni. (Pentru Nos),
-Website Item Group,Site-ul Grupa de articole,
-Cross Listing of Item in multiple groups,Crucea Listarea de punctul în mai multe grupuri,
-Default settings for Shopping Cart,Setările implicite pentru Cosul de cumparaturi,
-Enable Shopping Cart,Activați cosul de cumparaturi,
-Display Settings,Display Settings,
-Show Public Attachments,Afișați atașamentele publice,
-Show Price,Afișați prețul,
-Show Stock Availability,Afișați disponibilitatea stocului,
-Show Contact Us Button,Afișați butonul de contactare,
-Show Stock Quantity,Afișați cantitatea stocului,
-Show Apply Coupon Code,Afișați Aplicați codul de cupon,
-Allow items not in stock to be added to cart,Permiteți adăugarea în coș a articolelor care nu sunt în stoc,
-Prices will not be shown if Price List is not set,Prețurile nu vor fi afișate în cazul în care Prețul de listă nu este setat,
-Quotation Series,Ofertă Series,
-Checkout Settings,setările checkout pentru,
-Enable Checkout,activaţi Checkout,
-Payment Success Url,Plată de succes URL,
-After payment completion redirect user to selected page.,După finalizarea plății redirecționați utilizatorul la pagina selectată.,
-Batch Details,Detalii lot,
-Batch ID,ID-ul lotului,
-image,imagine,
-Parent Batch,Lotul părinte,
-Manufacturing Date,Data Fabricației,
-Batch Quantity,Cantitatea lotului,
-Batch UOM,Lot UOM,
-Source Document Type,Tipul documentului sursă,
-Source Document Name,Numele sursei de document,
-Batch Description,Descriere lot,
-Bin,Coş,
-Reserved Quantity,Cantitate rezervata,
-Actual Quantity,Cantitate Efectivă,
-Requested Quantity,Cantitate Solicitată,
-Reserved Qty for sub contract,Cantitate rezervată pentru subcontract,
-Moving Average Rate,Rata medie mobilă,
-FCFS Rate,Rata FCFS,
-Customs Tariff Number,Tariful vamal Număr,
-Tariff Number,Tarif Număr,
-Delivery To,De Livrare la,
-MAT-DN-.YYYY.-,MAT-DN-.YYYY.-,
-Is Return,Este de returnare,
-Issue Credit Note,Eliberați nota de credit,
-Return Against Delivery Note,Reveni Împotriva livrare Nota,
-Customer's Purchase Order No,Nr. Comanda de Aprovizionare Client,
-Billing Address Name,Numele din adresa de facturare,
-Required only for sample item.,Necesar numai pentru articolul de probă.,
-"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Dacă ați creat un model standard la taxele de vânzare și taxe Format, selectați una și faceți clic pe butonul de mai jos.",
-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 (Export) will be visible once you save the Delivery Note.,În cuvinte (de export) va fi vizibil după ce a salva de livrare Nota.,
-Transporter Info,Info Transporter,
-Driver Name,Numele șoferului,
-Track this Delivery Note against any Project,Urmareste acest Livrare Note împotriva oricărui proiect,
-Inter Company Reference,Referință între companii,
-Print Without Amount,Imprima Fără Suma,
-% Installed,% Instalat,
-% of materials delivered against this Delivery Note,% de materiale livrate versus acest Aviz de Expeditie,
-Installation Status,Starea de instalare,
-Excise Page Number,Numărul paginii accize,
-Instructions,Instrucţiuni,
-From Warehouse,Din Depozit,
-Against Sales Order,Contra comenzii de vânzări,
-Against Sales Order Item,Contra articolului comenzii de vânzări,
-Against Sales Invoice,Comparativ facturii de vânzări,
-Against Sales Invoice Item,Comparativ articolului facturii de vânzări,
-Available Batch Qty at From Warehouse,Disponibil lot Cantitate puțin din Warehouse,
-Available Qty at From Warehouse,Cantitate Disponibil la Depozitul,
-Delivery Settings,Setări de livrare,
-Dispatch Settings,Dispecerat Setări,
-Dispatch Notification Template,Șablonul de notificare pentru expediere,
-Dispatch Notification Attachment,Expedierea notificării atașament,
-Leave blank to use the standard Delivery Note format,Lăsați necompletat pentru a utiliza formatul standard de livrare,
-Send with Attachment,Trimiteți cu atașament,
-Delay between Delivery Stops,Întârziere între opririle de livrare,
-Delivery Stop,Livrare Stop,
-Lock,Lacăt,
-Visited,Vizitat,
-Order Information,Informații despre comandă,
-Contact Information,Informatii de contact,
-Email sent to,Email trimis catre,
-Dispatch Information,Informații despre expediere,
-Estimated Arrival,Sosirea estimată,
-MAT-DT-.YYYY.-,MAT-DT-.YYYY.-,
-Initial Email Notification Sent,Notificarea inițială de e-mail trimisă,
-Delivery Details,Detalii Livrare,
-Driver Email,E-mail șofer,
-Driver Address,Adresa șoferului,
-Total Estimated Distance,Distanța totală estimată,
-Distance UOM,Distanță UOM,
-Departure Time,Timp de plecare,
-Delivery Stops,Livrarea se oprește,
-Calculate Estimated Arrival Times,Calculează Timp de Sosire Estimat,
-Use Google Maps Direction API to calculate estimated arrival times,Utilizați Google Maps Direction API pentru a calcula orele de sosire estimate,
-Optimize Route,Optimizați ruta,
-Use Google Maps Direction API to optimize route,Utilizați Google Maps Direction API pentru a optimiza ruta,
-In Transit,În trecere,
-Fulfillment User,Utilizator de încredere,
-"A Product or a Service that is bought, sold or kept in stock.","Un produs sau un serviciu care este cumpărat, vândut sau păstrat în stoc.",
-STO-ITEM-.YYYY.-,STO-ELEMENT-.YYYY.-,
-Variant Of,Varianta de,
-"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Dacă elementul este o variantă de un alt element atunci descriere, imagine, de stabilire a prețurilor, impozite etc vor fi stabilite de șablon dacă nu se specifică în mod explicit",
-Is Item from Hub,Este element din Hub,
-Default Unit of Measure,Unitatea de Măsură Implicita,
-Maintain Stock,Articol Stocabil,
-Standard Selling Rate,Standard de vânzare Rata,
-Auto Create Assets on Purchase,Creați active automate la achiziție,
-Asset Naming Series,Serie de denumire a activelor,
-Over Delivery/Receipt Allowance (%),Indemnizație de livrare / primire (%),
-Barcodes,Coduri de bare,
-Shelf Life In Days,Perioada de valabilitate în zile,
-End of Life,Sfârsitul vieții,
-Default Material Request Type,Implicit Material Tip de solicitare,
-Valuation Method,Metoda de evaluare,
-FIFO,FIFO,
-Moving Average,Mutarea medie,
-Warranty Period (in days),Perioada de garanție (în zile),
-Auto re-order,Re-comandă automată,
-Reorder level based on Warehouse,Nivel pentru re-comanda bazat pe Magazie,
-Will also apply for variants unless overrridden,Se va aplica și pentru variantele cu excepția cazului în overrridden,
-Units of Measure,Unitati de masura,
-Will also apply for variants,"Va aplică, de asemenea pentru variante",
-Serial Nos and Batches,Numere și loturi seriale,
-Has Batch No,Are nr. de Lot,
-Automatically Create New Batch,Creare automată Lot nou,
-Batch Number Series,Seria numerelor serii,
-"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.","Exemplu: ABCD. #####. Dacă seria este setată și numărul lotului nu este menționat în tranzacții, atunci numărul lotului automat va fi creat pe baza acestei serii. Dacă doriți întotdeauna să menționați în mod explicit numărul lotului pentru acest articol, lăsați acest lucru necompletat. Notă: această setare va avea prioritate față de Prefixul Seriei de Nomenclatoare din Setările de stoc.",
-Has Expiry Date,Are data de expirare,
-Retain Sample,Păstrați eșantionul,
-Max Sample Quantity,Cantitate maximă de probă,
-Maximum sample quantity that can be retained,Cantitatea maximă de mostră care poate fi reținută,
-Has Serial No,Are nr. de serie,
-Serial Number Series,Serial Number Series,
-"Example: ABCD.#####\nIf series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Exemplu:. ABCD ##### \n Dacă 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ă întotdeauna doriți să se menționeze explicit Serial nr de acest articol. părăsi acest gol.",
-Variants,Variante,
-Has Variants,Are variante,
-"If this item has variants, then it cannot be selected in sales orders etc.","Dacă acest element are variante, atunci nu poate fi selectat în comenzile de vânzări, etc.",
-Variant Based On,Varianta Bazat pe,
-Item Attribute,Postul Atribut,
-"Sales, Purchase, Accounting Defaults","Vânzări, Cumpărare, Definiții de contabilitate",
-Item Defaults,Elemente prestabilite,
-"Purchase, Replenishment Details","Detalii de achiziție, reconstituire",
-Is Purchase Item,Este de cumparare Articol,
-Default Purchase Unit of Measure,Unitatea de măsură prestabilită a măsurii,
-Minimum Order Qty,Comanda minima Cantitate,
-Minimum quantity should be as per Stock UOM,Cantitatea minimă ar trebui să fie conform UOM-ului de stoc,
-Average time taken by the supplier to deliver,Timpul mediu luate de către furnizor de a livra,
-Is Customer Provided Item,Este articol furnizat de client,
-Delivered by Supplier (Drop Ship),Livrate de Furnizor (Drop navelor),
-Supplier Items,Furnizor Articole,
-Foreign Trade Details,Detalii Comerț Exterior,
-Country of Origin,Tara de origine,
-Sales Details,Detalii Vânzări,
-Default Sales Unit of Measure,Unitatea de vânzare standard de măsură,
-Is Sales Item,Este produs de vânzări,
-Max Discount (%),Max Discount (%),
-No of Months,Numărul de luni,
-Customer Items,Articole clientului,
-Inspection Criteria,Criteriile de inspecție,
-Inspection Required before Purchase,Necesar de inspecție înainte de achiziționare,
-Inspection Required before Delivery,Necesar de inspecție înainte de livrare,
-Default BOM,FDM Implicit,
-Supply Raw Materials for Purchase,Materii prime de alimentare pentru cumparare,
-If subcontracted to a vendor,Dacă subcontractat la un furnizor,
-Customer Code,Cod client,
-Default Item Manufacturer,Producător de articole implicit,
-Default Manufacturer Part No,Cod producător implicit,
-Show in Website (Variant),Afișați în site-ul (Variant),
-Items with higher weightage will be shown higher,Articole cu weightage mare va fi afișat mai mare,
-Show a slideshow at the top of the page,Arata un slideshow din partea de sus a paginii,
-Website Image,Imagine Web,
-Website Warehouse,Website Depozit,
-"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.",
-Website Item Groups,Site-ul Articol Grupuri,
-List this Item in multiple groups on the website.,Listeaza acest articol in grupuri multiple de pe site-ul.\,
-Copy From Item Group,Copiere din Grupul de Articole,
-Website Content,Conținutul site-ului web,
-You can use any valid Bootstrap 4 markup in this field. It will be shown on your Item Page.,Puteți utiliza orice marcaj Bootstrap 4 valabil în acest câmp. Acesta va fi afișat pe pagina dvs. de articole.,
-Total Projected Qty,Cantitate totală prevăzută,
-Hub Publishing Details,Detalii privind publicarea Hubului,
-Publish in Hub,Publica in Hub,
-Publish Item to hub.erpnext.com,Publica Postul de hub.erpnext.com,
-Hub Category to Publish,Categorie Hub pentru publicare,
-Hub Warehouse,Hub Depozit,
-"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.","Publicați &quot;În stoc&quot; sau &quot;Nu este în stoc&quot; pe Hub, pe baza stocurilor disponibile în acest depozit.",
-Synced With Hub,Sincronizat cu Hub,
-Item Alternative,Alternativă la element,
-Alternative Item Code,Codul elementului alternativ,
-Two-way,Două căi,
-Alternative Item Name,Numele elementului alternativ,
-Attribute Name,Denumire atribut,
-Numeric Values,Valori numerice,
-From Range,Din gama,
-Increment,Creștere,
-To Range,La gama,
-Item Attribute Values,Valori Postul Atribut,
-Item Attribute Value,Postul caracteristicii Valoarea,
-Attribute Value,Valoare Atribut,
-Abbreviation,Abreviere,
-"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","Acest lucru va fi adăugat la Codul punctul de varianta. De exemplu, în cazul în care abrevierea este ""SM"", iar codul produs face ""T-SHIRT"", codul punctul de varianta va fi ""T-SHIRT-SM""",
-Item Barcode,Element de coduri de bare,
-Barcode Type,Tip de cod de bare,
-EAN,EAN,
-UPC-A,UPC-A,
-Item Customer Detail,Detaliu Articol Client,
-"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",
-Ref Code,Cod de Ref,
-Item Default,Element Implicit,
-Purchase Defaults,Valori implicite pentru achiziții,
-Default Buying Cost Center,Centru de Cost Cumparare Implicit,
-Default Supplier,Furnizor Implicit,
-Default Expense Account,Cont de Cheltuieli Implicit,
-Sales Defaults,Setări prestabilite pentru vânzări,
-Default Selling Cost Center,Centru de Cost Vanzare Implicit,
-Item Manufacturer,Postul Producator,
-Item Price,Preț Articol,
-Packing Unit,Unitate de ambalare,
-Quantity  that must be bought or sold per UOM,Cantitatea care trebuie cumpărată sau vândută pe UOM,
-Item Quality Inspection Parameter,Parametru Inspecție de Calitate Articol,
-Acceptance Criteria,Criteriile de receptie,
-Item Reorder,Reordonare Articol,
-Check in (group),Check-in (grup),
-Request for,Cerere pentru,
-Re-order Level,Nivelul de re-comandă,
-Re-order Qty,Re-comanda Cantitate,
-Item Supplier,Furnizor Articol,
-Item Variant,Postul Varianta,
-Item Variant Attribute,Varianta element Atribut,
-Do not update variants on save,Nu actualizați variantele de salvare,
-Fields will be copied over only at time of creation.,Câmpurile vor fi copiate numai în momentul creării.,
-Allow Rename Attribute Value,Permiteți redenumirea valorii atributului,
-Rename Attribute Value in Item Attribute.,Redenumiți valoarea atributului în atributul de element.,
-Copy Fields to Variant,Copiați câmpurile în varianta,
-Item Website Specification,Specificație Site Articol,
-Table for Item that will be shown in Web Site,Tabelul pentru postul care va fi afișat în site-ul,
-Landed Cost Item,Cost Final Articol,
-Receipt Document Type,Primire Tip de document,
-Receipt Document,Documentul de primire,
-Applicable Charges,Taxe aplicabile,
-Purchase Receipt Item,Primirea de cumpărare Postul,
-Landed Cost Purchase Receipt,Chitanta de Cumparare aferent Costului Final,
-Landed Cost Taxes and Charges,Impozite cost debarcate și Taxe,
-Landed Cost Voucher,Voucher Cost Landed,
-MAT-LCV-.YYYY.-,MAT-LCV-.YYYY.-,
-Purchase Receipts,Încasări de cumparare,
-Purchase Receipt Items,Primirea de cumpărare Articole,
-Get Items From Purchase Receipts,Obține elemente din achiziție Încasări,
-Distribute Charges Based On,Împărțiți taxelor pe baza,
-Landed Cost Help,Costul Ajutor Landed,
-Manufacturers used in Items,Producători utilizați în Articole,
-Limited to 12 characters,Limitată la 12 de caractere,
-MAT-MR-.YYYY.-,MAT-MR-.YYYY.-,
-Partially Ordered,Parțial comandat,
-Transferred,transferat,
-% Ordered,% Comandat,
-Terms and Conditions Content,Termeni și condiții de conținut,
-Quantity and Warehouse,Cantitatea și Warehouse,
-Lead Time Date,Data Timp Conducere,
-Min Order Qty,Min Ordine Cantitate,
-Packed Item,Articol ambalate,
-To Warehouse (Optional),La Depozit (opțional),
-Actual Batch Quantity,Cantitatea actuală de lot,
-Prevdoc DocType,Prevdoc Doctype,
-Parent Detail docname,Părinte Detaliu docname,
-"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generarea de ambalare slip pentru pachetele de a fi livrate. Folosit pentru a notifica numărul pachet, conținutul pachetului și greutatea sa.",
-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),
-MAT-PAC-.YYYY.-,MAT-PAC-.YYYY.-,
-From Package No.,Din Pachetul Nr.,
-Identification of the package for the delivery (for print),Identificarea pachetului pentru livrare (pentru imprimare),
-To Package No.,La pachetul Nr,
-If more than one package of the same type (for print),În cazul în care mai mult de un pachet de același tip (pentru imprimare),
-Package Weight Details,Pachetul Greutate Detalii,
-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),
-Net Weight UOM,Greutate neta UOM,
-Gross Weight,Greutate brută,
-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)",
-Gross Weight UOM,Greutate Brută UOM,
-Packing Slip Item,Bonul Articol,
-DN Detail,Detaliu DN,
-STO-PICK-.YYYY.-,STO-PICK-.YYYY.-,
-Material Transfer for Manufacture,Transfer de materii pentru fabricarea,
-Qty of raw materials will be decided based on the qty of the Finished Goods Item,Cantitatea de materii prime va fi decisă pe baza cantității articolului de produse finite,
-Parent Warehouse,Depozit Părinte,
-Items under this warehouse will be suggested,Articolele din acest depozit vor fi sugerate,
-Get Item Locations,Obțineți locații de articole,
-Item Locations,Locații articol,
-Pick List Item,Alegeți articolul din listă,
-Picked Qty,Cules Qty,
-Price List Master,Lista de preturi Masterat,
-Price List Name,Lista de prețuri Nume,
-Price Not UOM Dependent,Pretul nu este dependent de UOM,
-Applicable for Countries,Aplicabile pentru țările,
-Price List Country,Lista de preturi Țară,
-MAT-PRE-.YYYY.-,MAT-PRE-.YYYY.-,
-Supplier Delivery Note,Nota de livrare a furnizorului,
-Time at which materials were received,Timp în care s-au primit materiale,
-Return Against Purchase Receipt,Reveni cu confirmare de primire cumparare,
-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,
-Sets 'Accepted Warehouse' in each row of the items table.,Setează „Depozit acceptat” în fiecare rând al tabelului cu articole.,
-Sets 'Rejected Warehouse' in each row of the items table.,Setează „Depozit respins” în fiecare rând al tabelului cu articole.,
-Raw Materials Consumed,Materii prime consumate,
-Get Current Stock,Obține stocul curent,
-Consumed Items,Articole consumate,
-Add / Edit Taxes and Charges,Adaugaţi / editaţi taxe și cheltuieli,
-Auto Repeat Detail,Repeatarea detaliilor automate,
-Transporter Details,Detalii Transporter,
-Vehicle Number,Numărul de vehicule,
-Vehicle Date,Vehicul Data,
-Received and Accepted,Primit și Acceptat,
-Accepted Quantity,Cantitatea Acceptata,
-Rejected Quantity,Cantitate Respinsă,
-Accepted Qty as per Stock UOM,Cantitate acceptată conform stocului UOM,
-Sample Quantity,Cantitate de probă,
-Rate and Amount,Rata și volumul,
-MAT-QA-.YYYY.-,MAT-QA-.YYYY.-,
-Report Date,Data raportului,
-Inspection Type,Inspecție Tip,
-Item Serial No,Nr. de Serie Articol,
-Sample Size,Eșantionul de dimensiune,
-Inspected By,Inspectat de,
-Readings,Lecturi,
-Quality Inspection Reading,Inspecție de calitate Reading,
-Reading 1,Lectura 1,
-Reading 2,Lectura 2,
-Reading 3,Lectura 3,
-Reading 4,Lectura 4,
-Reading 5,Lectura 5,
-Reading 6,Lectura 6,
-Reading 7,Lectură 7,
-Reading 8,Lectură 8,
-Reading 9,Lectură 9,
-Reading 10,Lectura 10,
-Quality Inspection Template Name,Numele de șablon de inspecție a calității,
-Quick Stock Balance,Soldul rapid al stocurilor,
-Available Quantity,Cantitate Disponibilă,
-Distinct unit of an Item,Unitate distinctă de Postul,
-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,
-Purchase / Manufacture Details,Detalii de cumpărare / Fabricarea,
-Creation Document Type,Tip de document creație,
-Creation Document No,Creare Document Nr.,
-Creation Date,Data creării,
-Creation Time,Timp de creare,
-Asset Details,Detalii privind activul,
-Asset Status,Starea activelor,
-Delivery Document Type,Tipul documentului de Livrare,
-Delivery Document No,Nr. de document de Livrare,
-Delivery Time,Timp de Livrare,
-Invoice Details,Detaliile facturii,
-Warranty / AMC Details,Garanție / AMC Detalii,
-Warranty Expiry Date,Garanție Data expirării,
-AMC Expiry Date,Dată expirare AMC,
-Under Warranty,În garanție,
-Out of Warranty,Ieșit din garanție,
-Under AMC,Sub AMC,
-Out of AMC,Din AMC,
-Warranty Period (Days),Perioada de garanție (zile),
-Serial No Details,Serial Nu Detalii,
-MAT-STE-.YYYY.-,MAT-STE-.YYYY.-,
-Stock Entry Type,Tip intrare stoc,
-Stock Entry (Outward GIT),Intrare pe stoc (GIT exterior),
-Material Consumption for Manufacture,Consumul de materiale pentru fabricare,
-Repack,Reambalați,
-Send to Subcontractor,Trimiteți către subcontractant,
-Delivery Note No,Nr. Nota de Livrare,
-Sales Invoice No,Nr. Factură de Vânzări,
-Purchase Receipt No,Primirea de cumpărare Nu,
-Inspection Required,Inspecție obligatorii,
-From BOM,De la BOM,
-For Quantity,Pentru Cantitate,
-As per Stock UOM,Ca şi pentru stoc UOM,
-Including items for sub assemblies,Inclusiv articole pentru subansambluri,
-Default Source Warehouse,Depozit Sursa Implicit,
-Source Warehouse Address,Adresă Depozit Sursă,
-Default Target Warehouse,Depozit Tinta Implicit,
-Target Warehouse Address,Adresa de destinație a depozitului,
-Update Rate and Availability,Actualizarea Rata și disponibilitatea,
-Total Incoming Value,Valoarea totală a sosi,
-Total Outgoing Value,Valoarea totală de ieșire,
-Total Value Difference (Out - In),Diferența Valoarea totală (Out - In),
-Additional Costs,Costuri suplimentare,
-Total Additional Costs,Costuri totale suplimentare,
-Customer or Supplier Details,Client sau furnizor Detalii,
-Per Transferred,Per transferat,
-Stock Entry Detail,Stoc de intrare Detaliu,
-Basic Rate (as per Stock UOM),Rata de bază (conform Stock UOM),
-Basic Amount,Suma de bază,
-Additional Cost,Cost aditional,
-Serial No / Batch,Serial No / lot,
-BOM No. for a Finished Good Item,Nr. BOM pentru un articol tip produs finalizat,
-Material Request used to make this Stock Entry,Cerere de material utilizat pentru a face acest stoc de intrare,
-Subcontracted Item,Subcontractat element,
-Against Stock Entry,Împotriva intrării pe stoc,
-Stock Entry Child,Copil de intrare în stoc,
-PO Supplied Item,PO Articol furnizat,
-Reference Purchase Receipt,Recepție de achiziție de achiziție,
-Stock Ledger Entry,Registru Contabil Intrări,
-Outgoing Rate,Rata de ieșire,
-Actual Qty After Transaction,Cant. efectivă după tranzacție,
-Stock Value Difference,Valoarea Stock Diferența,
-Stock Queue (FIFO),Stoc Queue (FIFO),
-Is Cancelled,Este anulat,
-Stock Reconciliation,Stoc Reconciliere,
-This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,Acest instrument vă ajută să actualizați sau stabili cantitatea și evaluarea stocului in sistem. Acesta este de obicei folosit pentru a sincroniza valorile de sistem și ceea ce există de fapt în depozite tale.,
-MAT-RECO-.YYYY.-,MAT-RECO-.YYYY.-,
-Reconciliation JSON,Reconciliere JSON,
-Stock Reconciliation Item,Stock reconciliere Articol,
-Before reconciliation,Premergător reconcilierii,
-Current Serial No,Serial curent nr,
-Current Valuation Rate,Rata de evaluare curentă,
-Current Amount,Suma curentă,
-Quantity Difference,cantitate diferenţă,
-Amount Difference,suma diferenţă,
-Item Naming By,Denumire Articol Prin,
-Default Item Group,Group Articol Implicit,
-Default Stock UOM,Stoc UOM Implicit,
-Sample Retention Warehouse,Exemplu de reținere depozit,
-Default Valuation Method,Metoda de Evaluare Implicită,
-Show Barcode Field,Afișează coduri de bare Câmp,
-Convert Item Description to Clean HTML,Conversia elementului de articol pentru a curăța codul HTML,
-Allow Negative Stock,Permiteţi stoc negativ,
-Automatically Set Serial Nos based on FIFO,Setat automat Serial nr bazat pe FIFO,
-Auto Material Request,Cerere automată de material,
-Inter Warehouse Transfer Settings,Setări de transfer între depozite,
-Freeze Stock Entries,Blocheaza Intrarile in Stoc,
-Stock Frozen Upto,Stoc Frozen Până la,
-Batch Identification,Identificarea lotului,
-Use Naming Series,Utilizați seria de numire,
-Naming Series Prefix,Denumirea prefixului seriei,
-UOM Category,Categoria UOM,
-UOM Conversion Detail,Detaliu UOM de conversie,
-Variant Field,Varianta câmpului,
-A logical Warehouse against which stock entries are made.,Un depozit logic față de care se efectuează înregistrări de stoc.,
-Warehouse Detail,Detaliu Depozit,
-Warehouse Name,Denumire Depozit,
-Warehouse Contact Info,Date de contact depozit,
-PIN,PIN,
-ISS-.YYYY.-,ISS-.YYYY.-,
-Raised By (Email),Ridicat de (E-mail),
-Issue Type,Tipul problemei,
-Issue Split From,Problemă Split From,
-Service Level,Nivel de servicii,
-Response By,Răspuns de,
-Response By Variance,Răspuns după variație,
-Ongoing,În curs de desfășurare,
-Resolution By,Rezolvare de,
-Resolution By Variance,Rezolutie prin variatie,
-Service Level Agreement Creation,Crearea contractului de nivel de serviciu,
-First Responded On,Primul Răspuns la,
-Resolution Details,Detalii Rezoluție,
-Opening Date,Data deschiderii,
-Opening Time,Timp de deschidere,
-Resolution Date,Dată Rezoluție,
-Via Customer Portal,Prin portalul de clienți,
-Support Team,Echipa de Suport,
-Issue Priority,Prioritate de emisiune,
-Service Day,Ziua serviciului,
-Workday,Zi de lucru,
-Default Priority,Prioritate implicită,
-Priorities,priorităţi,
-Support Hours,Ore de sprijin,
-Support and Resolution,Suport și rezoluție,
-Default Service Level Agreement,Acordul implicit privind nivelul serviciilor,
-Entity,Entitate,
-Agreement Details,Detalii despre acord,
-Response and Resolution Time,Timp de răspuns și rezolvare,
-Service Level Priority,Prioritate la nivel de serviciu,
-Resolution Time,Timp de rezoluție,
-Support Search Source,Sprijiniți sursa de căutare,
-Source Type,Tipul sursei,
-Query Route String,Query String Rout,
-Search Term Param Name,Termenul de căutare Param Name,
-Response Options,Opțiuni de Răspuns,
-Response Result Key Path,Răspuns Rezultat Cale cheie,
-Post Route String,Postați șirul de rută,
-Post Route Key List,Afișați lista cheilor de rutare,
-Post Title Key,Titlul mesajului cheie,
-Post Description Key,Post Descriere cheie,
-Link Options,Link Opțiuni,
-Source DocType,Sursa DocType,
-Result Title Field,Câmp rezultat titlu,
-Result Preview Field,Câmp de examinare a rezultatelor,
-Result Route Field,Câmp de rutare rezultat,
-Service Level Agreements,Acorduri privind nivelul serviciilor,
-Track Service Level Agreement,Urmăriți acordul privind nivelul serviciilor,
-Allow Resetting Service Level Agreement,Permiteți resetarea contractului de nivel de serviciu,
-Close Issue After Days,Închide Problemă După Zile,
-Auto close Issue after 7 days,Închidere automată Problemă după 7 zile,
-Support Portal,Portal de suport,
-Get Started Sections,Începeți secțiunile,
-Show Latest Forum Posts,Arată ultimele postări pe forum,
-Forum Posts,Mesaje pe forum,
-Forum URL,Adresa URL a forumului,
-Get Latest Query,Obțineți ultima interogare,
-Response Key List,Listă cu chei de răspuns,
-Post Route Key,Introduceți cheia de rutare,
-Search APIs,API-uri de căutare,
-SER-WRN-.YYYY.-,SER-WRN-.YYYY.-,
-Issue Date,Data emiterii,
-Item and Warranty Details,Postul și garanție Detalii,
-Warranty / AMC Status,Garanție / AMC Starea,
-Resolved By,Rezolvat prin,
-Service Address,Adresa serviciu,
-If different than customer address,Dacă diferă de adresa client,
-Raised By,Ridicat De,
-From Company,De la Compania,
-Rename Tool,Instrument Redenumire,
-Utilities,Utilitați,
-Type of document to rename.,Tip de document pentru a redenumi.,
-File to Rename,Fișier de Redenumiți,
-"Attach .csv file with two columns, one for the old name and one for the new name","Atașați fișier .csv cu două coloane, una pentru denumirea veche și una pentru denumirea nouă",
-Rename Log,Redenumi Conectare,
-SMS Log,SMS Conectare,
-Sender Name,Sender Name,
-Sent On,A trimis pe,
-No of Requested SMS,Nu de SMS solicitat,
-Requested Numbers,Numere solicitate,
-No of Sent SMS,Nu de SMS-uri trimise,
-Sent To,Trimis La,
-Absent Student Report,Raport elev absent,
-Assessment Plan Status,Starea planului de evaluare,
-Asset Depreciation Ledger,Registru Amortizatre Active,
-Asset Depreciations and Balances,Amortizari si Balante Active,
-Available Stock for Packing Items,Stoc disponibil pentru articole destinate împachetării,
-Bank Clearance Summary,Sumar aprobare bancă,
-Bank Remittance,Transferul bancar,
-Batch Item Expiry Status,Lot Articol Stare de expirare,
-Batch-Wise Balance History,Istoricul balanţei principale aferente lotului,
-BOM Explorer,BOM Explorer,
-BOM Search,BOM Căutare,
-BOM Stock Calculated,BOM Stocul calculat,
-BOM Variance Report,BOM Raport de variație,
-Campaign Efficiency,Eficiența campaniei,
-Cash Flow,Fluxul de numerar,
-Completed Work Orders,Ordine de lucru finalizate,
-To Produce,Pentru a produce,
-Produced,Produs,
-Consolidated Financial Statement,Situație financiară consolidată,
-Course wise Assessment Report,Raport de evaluare în curs,
-Customer Acquisition and Loyalty,Achiziționare și Loialitate Client,
-Customer Credit Balance,Balanța Clienți credit,
-Customer Ledger Summary,Rezumatul evidenței clienților,
-Customer-wise Item Price,Prețul articolului pentru clienți,
-Customers Without Any Sales Transactions,Clienții fără tranzacții de vânzare,
-Daily Timesheet Summary,Rezumat Pontaj Zilnic,
-Daily Work Summary Replies,Rezumat zilnic de lucrări,
-DATEV,DATEV,
-Delayed Item Report,Raportul întârziat al articolului,
-Delayed Order Report,Raportul de comandă întârziat,
-Delivered Items To Be Billed,Produse Livrate Pentru a fi Facturate,
-Delivery Note Trends,Tendințe Nota de Livrare,
-Electronic Invoice Register,Registrul electronic al facturilor,
-Employee Advance Summary,Sumarul avansului pentru angajați,
-Employee Billing Summary,Rezumatul facturării angajaților,
-Employee Birthday,Zi de naștere angajat,
-Employee Information,Informații angajat,
-Employee Leave Balance,Bilant Concediu Angajat,
-Employee Leave Balance Summary,Rezumatul soldului concediilor angajaților,
-Employees working on a holiday,Numar de angajati care lucreaza in vacanta,
-Eway Bill,Eway Bill,
-Expiring Memberships,Expirarea calității de membru,
-Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptabile [FEC],
-Final Assessment Grades,Evaluări finale,
-Fixed Asset Register,Registrul activelor fixe,
-Gross and Net Profit Report,Raport de profit brut și net,
-GST Itemised Purchase Register,GST Registrul achiziționărilor detaliate,
-GST Itemised Sales Register,Registrul de vânzări detaliat GST,
-GST Purchase Register,Registrul achizițiilor GST,
-GST Sales Register,Registrul vânzărilor GST,
-GSTR-1,GSTR-1,
-GSTR-2,GSTR-2,
-Hotel Room Occupancy,Hotel Ocuparea camerei,
-HSN-wise-summary of outward supplies,Rezumatul HSN pentru rezervele exterioare,
-Inactive Customers,Clienții inactive,
-Inactive Sales Items,Articole de vânzare inactive,
-IRS 1099,IRS 1099,
-Issued Items Against Work Order,Articole emise împotriva comenzii de lucru,
-Projected Quantity as Source,Cantitatea ca sursă proiectată,
-Item Balance (Simple),Balanța postului (simplă),
-Item Price Stock,Preț Stoc Articol,
-Item Prices,Preturi Articol,
-Item Shortage Report,Raport Articole Lipsa,
-Item Variant Details,Element Variant Details,
-Item-wise Price List Rate,Rata Lista de Pret Articol-Avizat,
-Item-wise Purchase History,Istoric Achizitii Articol-Avizat,
-Item-wise Purchase Register,Registru Achizitii Articol-Avizat,
-Item-wise Sales History,Istoric Vanzari Articol-Avizat,
-Item-wise Sales Register,Registru Vanzari Articol-Avizat,
-Items To Be Requested,Articole care vor fi solicitate,
-Reserved,Rezervat,
-Itemwise Recommended Reorder Level,Nivel de Reordonare Recomandat al Articolului-Awesome,
-Lead Details,Detalii Pistă,
-Lead Owner Efficiency,Lead Efficiency Owner,
-Loan Repayment and Closure,Rambursarea împrumutului și închiderea,
-Loan Security Status,Starea de securitate a împrumutului,
-Lost Opportunity,Oportunitate pierdută,
-Maintenance Schedules,Program de Mentenanta,
-Material Requests for which Supplier Quotations are not created,Cererile de materiale pentru care nu sunt create Cotațiile Furnizor,
-Monthly Attendance Sheet,Lunar foaia de prezență,
-Open Work Orders,Deschideți comenzile de lucru,
-Qty to Deliver,Cantitate pentru a oferi,
-Patient Appointment Analytics,Analiza programării pacientului,
-Payment Period Based On Invoice Date,Perioada de plată Bazat pe Data facturii,
-Pending SO Items For Purchase Request,Până la SO articole pentru cerere de oferta,
-Procurement Tracker,Urmărirea achizițiilor,
-Product Bundle Balance,Soldul pachetului de produse,
-Production Analytics,Google Analytics de producție,
-Profit and Loss Statement,Profit și pierdere,
-Profitability Analysis,Analiza profitabilității,
-Project Billing Summary,Rezumatul facturării proiectului,
-Project wise Stock Tracking,Urmărirea proiectului în funcție de stoc,
-Project wise Stock Tracking ,Proiect înțelept Tracking Stock,
-Prospects Engaged But Not Converted,Perspective implicate dar nu convertite,
-Purchase Analytics,Analytics de cumpărare,
-Purchase Invoice Trends,Cumpărare Tendințe factură,
-Qty to Receive,Cantitate de a primi,
-Received Qty Amount,Suma de cantitate primită,
-Billed Qty,Qty facturat,
-Purchase Order Trends,Comandă de aprovizionare Tendințe,
-Purchase Receipt Trends,Tendințe Primirea de cumpărare,
-Purchase Register,Cumpărare Inregistrare,
-Quotation Trends,Cotație Tendințe,
-Received Items To Be Billed,Articole primite Pentru a fi facturat,
-Qty to Order,Cantitate pentru comandă,
-Requested Items To Be Transferred,Articole solicitate de transferat,
-Qty to Transfer,Cantitate de a transfera,
-Salary Register,Salariu Înregistrare,
-Sales Analytics,Analitice de vânzare,
-Sales Invoice Trends,Vânzări Tendințe factură,
-Sales Order Trends,Vânzări Ordine Tendințe,
-Sales Partner Commission Summary,Rezumatul Comisiei partenere de vânzări,
-Sales Partner Target Variance based on Item Group,Varianța de țintă a partenerilor de vânzări bazată pe grupul de articole,
-Sales Partner Transaction Summary,Rezumat tranzacție partener vânzări,
-Sales Partners Commission,Comision Agenţi Vânzări,
-Invoiced Amount (Exclusive Tax),Suma facturată (taxă exclusivă),
-Average Commission Rate,Rată de comision medie,
-Sales Payment Summary,Rezumatul plăților pentru vânzări,
-Sales Person Commission Summary,Persoana de vânzări Rezumat al Comisiei,
-Sales Person Target Variance Based On Item Group,Vânzarea persoanei de vânzare Varianța bazată pe grupul de articole,
-Sales Person-wise Transaction Summary,Persoana de vânzări-înțelept Rezumat Transaction,
-Sales Register,Vânzări Inregistrare,
-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,
-Stock Ageing,Stoc Îmbătrânirea,
-Stock and Account Value Comparison,Comparația valorilor stocurilor și conturilor,
-Stock Projected Qty,Stoc proiectată Cantitate,
-Student and Guardian Contact Details,Student și Guardian Detalii de contact,
-Student Batch-Wise Attendance,Lot-înțelept elev Participarea,
-Student Fee Collection,Taxa de student Colectia,
-Student Monthly Attendance Sheet,Elev foaia de prezență lunară,
-Subcontracted Item To Be Received,Articol subcontractat care trebuie primit,
-Subcontracted Raw Materials To Be Transferred,Materii prime subcontractate care trebuie transferate,
-Supplier Ledger Summary,Rezumat evidență furnizor,
-Supplier-Wise Sales Analytics,Furnizor înțelept Vânzări Analytics,
-Support Hour Distribution,Distribuția orelor de distribuție,
-TDS Computation Summary,Rezumatul TDS de calcul,
-TDS Payable Monthly,TDS plătibil lunar,
-Territory Target Variance Based On Item Group,Varianța țintă de teritoriu pe baza grupului de articole,
-Territory-wise Sales,Vânzări înțelese teritoriul,
-Total Stock Summary,Rezumatul Total al Stocului,
-Trial Balance,Balanta,
-Trial Balance (Simple),Soldul de încercare (simplu),
-Trial Balance for Party,Trial Balance pentru Party,
-Unpaid Expense Claim,Solicitare Cheltuială Neachitată,
-Warehouse wise Item Balance Age and Value,Warehouse wise Item Balance Age și Value,
-Work Order Stock Report,Raport de stoc pentru comanda de lucru,
-Work Orders in Progress,Ordine de lucru în curs,
-Validation Error,eroare de validatie,
-Automatically Process Deferred Accounting Entry,Procesați automat intrarea contabilă amânată,
-Bank Clearance,Clearance bancar,
-Bank Clearance Detail,Detaliu de lichidare bancară,
-Update Cost Center Name / Number,Actualizați numele / numărul centrului de costuri,
-Journal Entry Template,Șablon de intrare în jurnal,
-Template Title,Titlul șablonului,
-Journal Entry Type,Tipul intrării în jurnal,
-Journal Entry Template Account,Cont șablon de intrare în jurnal,
-Process Deferred Accounting,Procesul de contabilitate amânată,
-Manual entry cannot be created! Disable automatic entry for deferred accounting in accounts settings and try again,Intrarea manuală nu poate fi creată! Dezactivați intrarea automată pentru contabilitatea amânată în setările conturilor și încercați din nou,
-End date cannot be before start date,Data de încheiere nu poate fi înainte de data de începere,
-Total Counts Targeted,Numărul total vizat,
-Total Counts Completed,Numărul total finalizat,
-Counts Targeted: {0},Număruri vizate: {0},
-Payment Account is mandatory,Contul de plată este obligatoriu,
-"If checked, the full amount will be deducted from taxable income before calculating income tax without any declaration or proof submission.","Dacă este bifat, suma totală va fi dedusă din venitul impozabil înainte de calcularea impozitului pe venit fără nicio declarație sau depunere de dovadă.",
-Disbursement Details,Detalii despre debursare,
-Material Request Warehouse,Depozit cerere material,
-Select warehouse for material requests,Selectați depozitul pentru solicitări de materiale,
-Transfer Materials For Warehouse {0},Transfer de materiale pentru depozit {0},
-Production Plan Material Request Warehouse,Plan de producție Cerere de materiale Depozit,
-Sets 'Source Warehouse' in each row of the items table.,Setează „Depozit sursă” în fiecare rând al tabelului cu articole.,
-Sets 'Target Warehouse' in each row of the items table.,Setează „Depozit țintă” în fiecare rând al tabelului cu articole.,
-Show Cancelled Entries,Afișați intrările anulate,
-Backdated Stock Entry,Intrare de stoc actualizată,
-Row #{}: Currency of {} - {} doesn't matches company currency.,Rândul # {}: moneda {} - {} nu se potrivește cu moneda companiei.,
-{} Assets created for {},{} Active create pentru {},
-{0} Number {1} is already used in {2} {3},{0} Numărul {1} este deja utilizat în {2} {3},
-Update Bank Clearance Dates,Actualizați datele de compensare bancară,
-Healthcare Practitioner: ,Practician medical:,
-Lab Test Conducted: ,Test de laborator efectuat:,
-Lab Test Event: ,Eveniment de test de laborator:,
-Lab Test Result: ,Rezultatul testului de laborator:,
-Clinical Procedure conducted: ,Procedura clinică efectuată:,
-Therapy Session Charges: {0},Taxe pentru sesiunea de terapie: {0},
-Therapy: ,Terapie:,
-Therapy Plan: ,Planul de terapie:,
-Total Counts Targeted: ,Număruri totale vizate:,
-Total Counts Completed: ,Numărul total finalizat:,
-Andaman and Nicobar Islands,Insulele Andaman și Nicobar,
-Andhra Pradesh,Andhra Pradesh,
-Arunachal Pradesh,Arunachal Pradesh,
-Assam,Assam,
-Bihar,Bihar,
-Chandigarh,Chandigarh,
-Chhattisgarh,Chhattisgarh,
-Dadra and Nagar Haveli,Dadra și Nagar Haveli,
-Daman and Diu,Daman și Diu,
-Delhi,Delhi,
-Goa,Goa,
-Gujarat,Gujarat,
-Haryana,Haryana,
-Himachal Pradesh,Himachal Pradesh,
-Jammu and Kashmir,Jammu și Kashmir,
-Jharkhand,Jharkhand,
-Karnataka,Karnataka,
-Kerala,Kerala,
-Lakshadweep Islands,Insulele Lakshadweep,
-Madhya Pradesh,Madhya Pradesh,
-Maharashtra,Maharashtra,
-Manipur,Manipur,
-Meghalaya,Meghalaya,
-Mizoram,Mizoram,
-Nagaland,Nagaland,
-Odisha,Odisha,
-Other Territory,Alt teritoriu,
-Pondicherry,Pondicherry,
-Punjab,Punjab,
-Rajasthan,Rajasthan,
-Sikkim,Sikkim,
-Tamil Nadu,Tamil Nadu,
-Telangana,Telangana,
-Tripura,Tripura,
-Uttar Pradesh,Uttar Pradesh,
-Uttarakhand,Uttarakhand,
-West Bengal,Bengalul de Vest,
-Is Mandatory,Este obligatoriu,
-Published on,publicat pe,
-Service Received But Not Billed,"Serviciu primit, dar nu facturat",
-Deferred Accounting Settings,Setări de contabilitate amânate,
-Book Deferred Entries Based On,Rezervați intrări amânate pe baza,
-Days,Zile,
-Months,Luni,
-Book Deferred Entries Via Journal Entry,Rezervați intrări amânate prin intrarea în jurnal,
-Submit Journal Entries,Trimiteți intrări în jurnal,
-If this is unchecked Journal Entries will be saved in a Draft state and will have to be submitted manually,"Dacă aceasta nu este bifată, jurnalele vor fi salvate într-o stare de schiță și vor trebui trimise manual",
-Enable Distributed Cost Center,Activați Centrul de cost distribuit,
-Distributed Cost Center,Centrul de cost distribuit,
-Dunning,Poftă,
-DUNN-.MM.-.YY.-,DUNN-.MM .-. YY.-,
-Overdue Days,Zile restante,
-Dunning Type,Tipul Dunning,
-Dunning Fee,Taxă Dunning,
-Dunning Amount,Suma Dunning,
-Resolved,S-a rezolvat,
-Unresolved,Nerezolvat,
-Printing Setting,Setare imprimare,
-Body Text,Corpul textului,
-Closing Text,Text de închidere,
-Resolve,Rezolva,
-Dunning Letter Text,Text scrisoare Dunning,
-Is Default Language,Este limba implicită,
-Letter or Email Body Text,Text pentru corp scrisoare sau e-mail,
-Letter or Email Closing Text,Text de închidere prin scrisoare sau e-mail,
-Body and Closing Text Help,Ajutor pentru corp și text de închidere,
-Overdue Interval,Interval întârziat,
-Dunning Letter,Scrisoare Dunning,
-"This section allows the user to set the Body and Closing text of the Dunning Letter for the Dunning Type based on language, which can be used in Print.","Această secțiune permite utilizatorului să seteze corpul și textul de închidere al Scrisorii Dunning pentru tipul Dunning în funcție de limbă, care poate fi utilizat în Tipărire.",
-Reference Detail No,Nr. Detalii referință,
-Custom Remarks,Observații personalizate,
-Please select a Company first.,Vă rugăm să selectați mai întâi o companie.,
-"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice, Journal Entry or Dunning","Rândul # {0}: tipul documentului de referință trebuie să fie unul dintre Comanda de vânzări, Factura de vânzări, Înregistrarea jurnalului sau Sarcina",
-POS Closing Entry,Intrare de închidere POS,
-POS Opening Entry,Intrare de deschidere POS,
-POS Transactions,Tranzacții POS,
-POS Closing Entry Detail,Detaliu intrare închidere POS,
-Opening Amount,Suma de deschidere,
-Closing Amount,Suma de închidere,
-POS Closing Entry Taxes,Taxe de intrare POS închidere,
-POS Invoice,Factură POS,
-ACC-PSINV-.YYYY.-,ACC-PSINV-.YYYY.-,
-Consolidated Sales Invoice,Factură de vânzări consolidată,
-Return Against POS Invoice,Reveniți împotriva facturii POS,
-Consolidated,Consolidat,
-POS Invoice Item,Articol factură POS,
-POS Invoice Merge Log,Jurnal de îmbinare a facturilor POS,
-POS Invoices,Facturi POS,
-Consolidated Credit Note,Nota de credit consolidată,
-POS Invoice Reference,Referință factură POS,
-Set Posting Date,Setați data de înregistrare,
-Opening Balance Details,Detalii sold deschidere,
-POS Opening Entry Detail,Detaliu intrare deschidere POS,
-POS Payment Method,Metoda de plată POS,
-Payment Methods,Metode de plata,
-Process Statement Of Accounts,Procesul de situație a conturilor,
-General Ledger Filters,Filtre majore,
-Customers,Clienți,
-Select Customers By,Selectați Clienți după,
-Fetch Customers,Aduceți clienții,
-Send To Primary Contact,Trimiteți la contactul principal,
-Print Preferences,Preferințe de imprimare,
-Include Ageing Summary,Includeți rezumatul îmbătrânirii,
-Enable Auto Email,Activați e-mailul automat,
-Filter Duration (Months),Durata filtrului (luni),
-CC To,CC To,
-Help Text,Text de ajutor,
-Emails Queued,E-mailuri la coadă,
-Process Statement Of Accounts Customer,Procesul extras de cont client,
-Billing Email,E-mail de facturare,
-Primary Contact Email,E-mail de contact principal,
-PSOA Cost Center,Centrul de cost PSOA,
-PSOA Project,Proiectul PSOA,
-ACC-PINV-RET-.YYYY.-,ACC-PINV-RET-.YYYY.-,
-Supplier GSTIN,Furnizor GSTIN,
-Place of Supply,Locul aprovizionării,
-Select Billing Address,Selectați Adresa de facturare,
-GST Details,Detalii GST,
-GST Category,Categoria GST,
-Registered Regular,Înregistrat regulat,
-Registered Composition,Compoziție înregistrată,
-Unregistered,Neînregistrat,
-SEZ,SEZ,
-Overseas,De peste mări,
-UIN Holders,Titulari UIN,
-With Payment of Tax,Cu plata impozitului,
-Without Payment of Tax,Fără plata impozitului,
-Invoice Copy,Copie factură,
-Original for Recipient,Original pentru Destinatar,
-Duplicate for Transporter,Duplicat pentru Transporter,
-Duplicate for Supplier,Duplicat pentru furnizor,
-Triplicate for Supplier,Triplicat pentru furnizor,
-Reverse Charge,Taxare inversă,
-Y,Da,
-N,N,
-E-commerce GSTIN,Comerț electronic GSTIN,
-Reason For Issuing document,Motivul eliberării documentului,
-01-Sales Return,01-Returnarea vânzărilor,
-02-Post Sale Discount,02-Reducere după vânzare,
-03-Deficiency in services,03-Deficiența serviciilor,
-04-Correction in Invoice,04-Corecție în factură,
-05-Change in POS,05-Modificare POS,
-06-Finalization of Provisional assessment,06-Finalizarea evaluării provizorii,
-07-Others,07-Altele,
-Eligibility For ITC,Eligibilitate pentru ITC,
-Input Service Distributor,Distribuitor de servicii de intrare,
-Import Of Service,Importul serviciului,
-Import Of Capital Goods,Importul de bunuri de capital,
-Ineligible,Neeligibil,
-All Other ITC,Toate celelalte ITC,
-Availed ITC Integrated Tax,Taxă integrată ITC disponibilă,
-Availed ITC Central Tax,Taxă centrală ITC disponibilă,
-Availed ITC State/UT Tax,Impozit ITC de stat / UT disponibil,
-Availed ITC Cess,Cess ITC disponibil,
-Is Nil Rated or Exempted,Este evaluat zero sau scutit,
-Is Non GST,Nu este GST,
-ACC-SINV-RET-.YYYY.-,ACC-SINV-RET-.YYYY.-,
-E-Way Bill No.,E-Way Bill nr.,
-Is Consolidated,Este consolidat,
-Billing Address GSTIN,Adresa de facturare GSTIN,
-Customer GSTIN,Client GSTIN,
-GST Transporter ID,ID GST Transporter,
-Distance (in km),Distanță (în km),
-Road,drum,
-Air,Aer,
-Rail,Feroviar,
-Ship,Navă,
-GST Vehicle Type,Tipul vehiculului GST,
-Over Dimensional Cargo (ODC),Marfă supradimensională (ODC),
-Consumer,Consumator,
-Deemed Export,Export estimat,
-Port Code,Cod port,
- Shipping Bill Number,Numărul facturii de expediere,
-Shipping Bill Date,Data facturii de expediere,
-Subscription End Date,Data de încheiere a abonamentului,
-Follow Calendar Months,Urmăriți lunile calendaristice,
-If this is checked subsequent new invoices will be created on calendar  month and quarter start dates irrespective of current invoice start date,"Dacă se verifică acest lucru, vor fi create noi facturi ulterioare în lunile calendaristice și în datele de începere a trimestrului, indiferent de data curentă de începere a facturii",
-Generate New Invoices Past Due Date,Generați facturi noi la scadență,
-New invoices will be generated as per schedule even if current invoices are unpaid or past due date,"Facturile noi vor fi generate conform programului, chiar dacă facturile curente sunt neplătite sau sunt scadente",
-Document Type ,Tipul documentului,
-Subscription Price Based On,Prețul abonamentului pe baza,
-Fixed Rate,Rata fixa,
-Based On Price List,Pe baza listei de prețuri,
-Monthly Rate,Rată lunară,
-Cancel Subscription After Grace Period,Anulați abonamentul după perioada de grație,
-Source State,Statul sursă,
-Is Inter State,Este statul Inter,
-Purchase Details,Detalii achiziție,
-Depreciation Posting Date,Data înregistrării amortizării,
-"By default, the Supplier Name is set as per the Supplier Name entered. If you want Suppliers to be named by a  ","În mod implicit, numele furnizorului este setat conform numelui furnizorului introdus. Dacă doriți ca Furnizorii să fie numiți de către un",
- choose the 'Naming Series' option.,alegeți opțiunea „Denumirea seriei”.,
-Configure the default Price List when creating a new Purchase transaction. Item prices will be fetched from this Price List.,Configurați lista de prețuri implicită atunci când creați o nouă tranzacție de cumpărare. Prețurile articolelor vor fi preluate din această listă de prețuri.,
-"If this option is configured 'Yes', ERPNext will prevent you from creating a Purchase Invoice or Receipt without creating a Purchase Order first. This configuration can be overridden for a particular supplier by enabling the 'Allow Purchase Invoice Creation Without Purchase Order' checkbox in the Supplier master.","Dacă această opțiune este configurată „Da”, ERPNext vă va împiedica să creați o factură de achiziție sau o chitanță fără a crea mai întâi o comandă de cumpărare. Această configurație poate fi anulată pentru un anumit furnizor activând caseta de selectare „Permite crearea facturii de cumpărare fără comandă de cumpărare” din masterul furnizorului.",
-"If this option is configured 'Yes', ERPNext will prevent you from creating a Purchase Invoice without creating a Purchase Receipt first. This configuration can be overridden for a particular supplier by enabling the 'Allow Purchase Invoice Creation Without Purchase Receipt' checkbox in the Supplier master.","Dacă această opțiune este configurată „Da”, ERPNext vă va împiedica să creați o factură de cumpărare fără a crea mai întâi o chitanță de cumpărare. Această configurație poate fi suprascrisă pentru un anumit furnizor activând caseta de selectare „Permite crearea facturii de cumpărare fără chitanță de cumpărare” din masterul furnizorului.",
-Quantity & Stock,Cantitate și stoc,
-Call Details,Detalii apel,
-Authorised By,Autorizat de,
-Signee (Company),Destinatar (companie),
-Signed By (Company),Semnat de (Companie),
-First Response Time,Timpul primului răspuns,
-Request For Quotation,Cerere de ofertă,
-Opportunity Lost Reason Detail,Detaliu despre motivul pierdut al oportunității,
-Access Token Secret,Accesează Token Secret,
-Add to Topics,Adăugați la subiecte,
-...Adding Article to Topics,... Adăugarea articolului la subiecte,
-Add Article to Topics,Adăugați un articol la subiecte,
-This article is already added to the existing topics,Acest articol este deja adăugat la subiectele existente,
-Add to Programs,Adăugați la Programe,
-Programs,Programe,
-...Adding Course to Programs,... Adăugarea cursului la programe,
-Add Course to Programs,Adăugați cursul la programe,
-This course is already added to the existing programs,Acest curs este deja adăugat la programele existente,
-Learning Management System Settings,Setările sistemului de management al învățării,
-Enable Learning Management System,Activați sistemul de gestionare a învățării,
-Learning Management System Title,Titlul sistemului de management al învățării,
-...Adding Quiz to Topics,... Adăugarea testului la subiecte,
-Add Quiz to Topics,Adăugați test la subiecte,
-This quiz is already added to the existing topics,Acest test este deja adăugat la subiectele existente,
-Enable Admission Application,Activați cererea de admitere,
-EDU-ATT-.YYYY.-,EDU-ATT-.YYYY.-,
-Marking attendance,Marcarea prezenței,
-Add Guardians to Email Group,Adăugați Gardieni în grupul de e-mail,
-Attendance Based On,Prezență bazată pe,
-Check this to mark the student as present in case the student is not attending the institute to participate or represent the institute in any event.\n\n,Bifați acest lucru pentru a marca studentul ca prezent în cazul în care studentul nu participă la institut pentru a participa sau pentru a reprezenta institutul în orice caz.,
-Add to Courses,Adăugați la Cursuri,
-...Adding Topic to Courses,... Adăugarea subiectului la cursuri,
-Add Topic to Courses,Adăugați subiect la cursuri,
-This topic is already added to the existing courses,Acest subiect este deja adăugat la cursurile existente,
-"If Shopify does not have a customer in the order, then while syncing the orders, the system will consider the default customer for the order","Dacă Shopify nu are un client în comandă, atunci în timp ce sincronizează comenzile, sistemul va lua în considerare clientul implicit pentru comandă",
-The accounts are set by the system automatically but do confirm these defaults,"Conturile sunt setate automat de sistem, dar confirmă aceste valori implicite",
-Default Round Off Account,Cont implicit rotunjit,
-Failed Import Log,Jurnal de importare eșuat,
-Fixed Error Log,S-a remediat jurnalul de erori,
-Company {0} already exists. Continuing will overwrite the Company and Chart of Accounts,Compania {0} există deja. Continuarea va suprascrie compania și planul de conturi,
-Meta Data,Meta Date,
-Unresolve,Nerezolvat,
-Create Document,Creați document,
-Mark as unresolved,Marcați ca nerezolvat,
-TaxJar Settings,Setări TaxJar,
-Sandbox Mode,Mod Sandbox,
-Enable Tax Calculation,Activați calculul impozitului,
-Create TaxJar Transaction,Creați tranzacția TaxJar,
-Credentials,Acreditări,
-Live API Key,Cheie API live,
-Sandbox API Key,Cheia API Sandbox,
-Configuration,Configurare,
-Tax Account Head,Șef cont fiscal,
-Shipping Account Head,Șef cont de expediere,
-Practitioner Name,Numele practicianului,
-Enter a name for the Clinical Procedure Template,Introduceți un nume pentru șablonul de procedură clinică,
-Set the Item Code which will be used for billing the Clinical Procedure.,Setați codul articolului care va fi utilizat pentru facturarea procedurii clinice.,
-Select an Item Group for the Clinical Procedure Item.,Selectați un grup de articole pentru articolul de procedură clinică.,
-Clinical Procedure Rate,Rata procedurii clinice,
-Check this if the Clinical Procedure is billable and also set the rate.,"Verificați acest lucru dacă procedura clinică este facturabilă și, de asemenea, setați rata.",
-Check this if the Clinical Procedure utilises consumables. Click ,Verificați acest lucru dacă procedura clinică utilizează consumabile. Clic,
- to know more,să afle mai multe,
-"You can also set the Medical Department for the template. After saving the document, an Item will automatically be created for billing this Clinical Procedure. You can then use this template while creating Clinical Procedures for Patients. Templates save you from filling up redundant data every single time. You can also create templates for other operations like Lab Tests, Therapy Sessions, etc.","De asemenea, puteți seta Departamentul medical pentru șablon. După salvarea documentului, un articol va fi creat automat pentru facturarea acestei proceduri clinice. Puteți utiliza apoi acest șablon în timp ce creați proceduri clinice pentru pacienți. Șabloanele vă scutesc de la completarea datelor redundante de fiecare dată. De asemenea, puteți crea șabloane pentru alte operații precum teste de laborator, sesiuni de terapie etc.",
-Descriptive Test Result,Rezultatul testului descriptiv,
-Allow Blank,Permiteți golul,
-Descriptive Test Template,Șablon de test descriptiv,
-"If you want to track Payroll and other HRMS operations for a Practitoner, create an Employee and link it here.","Dacă doriți să urmăriți salarizarea și alte operațiuni HRMS pentru un practician, creați un angajat și conectați-l aici.",
-Set the Practitioner Schedule you just created. This will be used while booking appointments.,Setați programul de practicanți pe care tocmai l-ați creat. Aceasta va fi utilizată la rezervarea programărilor.,
-Create a service item for Out Patient Consulting.,Creați un element de serviciu pentru consultarea externă a pacienților.,
-"If this Healthcare Practitioner works for the In-Patient Department, create a service item for Inpatient Visits.","Dacă acest profesionist din domeniul sănătății lucrează pentru departamentul internat, creați un articol de servicii pentru vizitele internate.",
-Set the Out Patient Consulting Charge for this Practitioner.,Stabiliți taxa pentru consultarea pacientului pentru acest practicant.,
-"If this Healthcare Practitioner also works for the In-Patient Department, set the inpatient visit charge for this Practitioner.","În cazul în care acest profesionist din domeniul sănătății lucrează și pentru secția de internare, stabiliți taxa de vizitare pentru acest practician.",
-"If checked, a customer will be created for every Patient. Patient Invoices will be created against this Customer. You can also select existing Customer while creating a Patient. This field is checked by default.","Dacă este bifat, va fi creat un client pentru fiecare pacient. Facturile pacientului vor fi create împotriva acestui client. De asemenea, puteți selecta clientul existent în timp ce creați un pacient. Acest câmp este bifat implicit.",
-Collect Registration Fee,Încasează taxa de înregistrare,
-"If your Healthcare facility bills registrations of Patients, you can check this and set the Registration Fee in the field below. Checking this will create new Patients with a Disabled status by default and will only be enabled after invoicing the Registration Fee.","Dacă unitatea medicală facturează înregistrările pacienților, puteți verifica acest lucru și puteți stabili taxa de înregistrare în câmpul de mai jos. Verificând acest lucru se vor crea noi pacienți cu starea Dezactivat în mod implicit și vor fi activate numai după facturarea Taxei de înregistrare.",
-Checking this will automatically create a Sales Invoice whenever an appointment is booked for a Patient.,Verificarea acestui lucru va crea automat o factură de vânzare ori de câte ori este rezervată o întâlnire pentru un pacient.,
-Healthcare Service Items,Produse pentru servicii medicale,
-"You can create a service item for Inpatient Visit Charge and set it here. Similarly, you can set up other Healthcare Service Items for billing in this section. Click ","Puteți crea un articol de serviciu pentru taxa de vizită internată și setați-l aici. În mod similar, puteți configura alte elemente de servicii medicale pentru facturare în această secțiune. Clic",
-Set up default Accounts for the Healthcare Facility,Configurați conturi implicite pentru unitatea medicală,
-"If you wish to override default accounts settings and configure the Income and Receivable accounts for Healthcare, you can do so here.","Dacă doriți să înlocuiți setările implicite ale conturilor și să configurați conturile de venituri și creanțe pentru asistență medicală, puteți face acest lucru aici.",
-Out Patient SMS alerts,Alerte SMS pentru pacienți,
-"If you want to send SMS alert on Patient Registration, you can enable this option. Similary, you can set up Out Patient SMS alerts for other functionalities in this section. Click ","Dacă doriți să trimiteți alertă SMS la înregistrarea pacientului, puteți activa această opțiune. În mod similar, puteți configura alerte SMS pentru pacient pentru alte funcționalități în această secțiune. Clic",
-Admission Order Details,Detalii comandă de admitere,
-Admission Ordered For,Admiterea comandată pentru,
-Expected Length of Stay,Durata de ședere preconizată,
-Admission Service Unit Type,Tipul unității de servicii de admitere,
-Healthcare Practitioner (Primary),Practician medical (primar),
-Healthcare Practitioner (Secondary),Practician medical (secundar),
-Admission Instruction,Instrucțiuni de admitere,
-Chief Complaint,Plângere șefă,
-Medications,Medicamente,
-Investigations,Investigații,
-Discharge Detials,Detalii de descărcare,
-Discharge Ordered Date,Data comandării descărcării,
-Discharge Instructions,Instrucțiuni de descărcare de gestiune,
-Follow Up Date,Data de urmărire,
-Discharge Notes,Note de descărcare de gestiune,
-Processing Inpatient Discharge,Procesarea externării internate,
-Processing Patient Admission,Procesarea admiterii pacientului,
-Check-in time cannot be greater than the current time,Ora de check-in nu poate fi mai mare decât ora curentă,
-Process Transfer,Transfer de proces,
-HLC-LAB-.YYYY.-,HLC-LAB-.YYYY.-,
-Expected Result Date,Data rezultatului așteptat,
-Expected Result Time,Timp de rezultat așteptat,
-Printed on,Tipărit pe,
-Requesting Practitioner,Practician solicitant,
-Requesting Department,Departamentul solicitant,
-Employee (Lab Technician),Angajat (tehnician de laborator),
-Lab Technician Name,Numele tehnicianului de laborator,
-Lab Technician Designation,Desemnarea tehnicianului de laborator,
-Compound Test Result,Rezultatul testului compus,
-Organism Test Result,Rezultatul testului de organism,
-Sensitivity Test Result,Rezultatul testului de sensibilitate,
-Worksheet Print,Imprimare foaie de lucru,
-Worksheet Instructions,Instrucțiuni pentru foaia de lucru,
-Result Legend Print,Imprimare legendă rezultat,
-Print Position,Poziția de imprimare,
-Bottom,Partea de jos,
-Top,Top,
-Both,Ambii,
-Result Legend,Legenda rezultatului,
-Lab Tests,Teste de laborator,
-No Lab Tests found for the Patient {0},Nu s-au găsit teste de laborator pentru pacient {0},
-"Did not send SMS, missing patient mobile number or message content.","Nu am trimis SMS-uri, lipsă numărul de mobil al pacientului sau conținutul mesajului.",
-No Lab Tests created,Nu au fost create teste de laborator,
-Creating Lab Tests...,Se creează teste de laborator ...,
-Lab Test Group Template,Șablon de grup de test de laborator,
-Add New Line,Adăugați o linie nouă,
-Secondary UOM,UOM secundar,
-"<b>Single</b>: Results which require only a single input.\n<br>\n<b>Compound</b>: Results which require multiple event inputs.\n<br>\n<b>Descriptive</b>: Tests which have multiple result components with manual result entry.\n<br>\n<b>Grouped</b>: Test templates which are a group of other test templates.\n<br>\n<b>No Result</b>: Tests with no results, can be ordered and billed but no Lab Test will be created. e.g.. Sub Tests for Grouped results","<b>Single</b> : Rezultate care necesită o singură intrare.<br> <b>Compus</b> : Rezultate care necesită mai multe intrări de evenimente.<br> <b>Descriptiv</b> : teste care au mai multe componente ale rezultatelor cu introducerea manuală a rezultatelor.<br> <b>Grupate</b> : șabloane de testare care sunt un grup de alte șabloane de testare.<br> <b>Niciun rezultat</b> : testele fără rezultate, pot fi comandate și facturate, dar nu va fi creat niciun test de laborator. de exemplu. Subteste pentru rezultate grupate",
-"If unchecked, the item will not be available in Sales Invoices for billing but can be used in group test creation. ","Dacă nu este bifat, articolul nu va fi disponibil în facturile de vânzare pentru facturare, dar poate fi utilizat la crearea testului de grup.",
-Description ,Descriere,
-Descriptive Test,Test descriptiv,
-Group Tests,Teste de grup,
-Instructions to be printed on the worksheet,Instrucțiuni care trebuie tipărite pe foaia de lucru,
-"Information to help easily interpret the test report, will be printed as part of the Lab Test result.",Informațiile care vor ajuta la interpretarea cu ușurință a raportului de testare vor fi tipărite ca parte a rezultatului testului de laborator.,
-Normal Test Result,Rezultat normal al testului,
-Secondary UOM Result,Rezultatul UOM secundar,
-Italic,Cursiv,
-Underline,Subliniați,
-Organism,Organism,
-Organism Test Item,Element de testare a organismului,
-Colony Population,Populația coloniei,
-Colony UOM,Colonia UOM,
-Tobacco Consumption (Past),Consumul de tutun (trecut),
-Tobacco Consumption (Present),Consumul de tutun (Prezent),
-Alcohol Consumption (Past),Consumul de alcool (trecut),
-Alcohol Consumption (Present),Consumul de alcool (prezent),
-Billing Item,Articol de facturare,
-Medical Codes,Coduri medicale,
-Clinical Procedures,Proceduri clinice,
-Order Admission,Admiterea comenzii,
-Scheduling Patient Admission,Programarea admiterii pacientului,
-Order Discharge,Descărcare comandă,
-Sample Details,Detalii mostre,
-Collected On,Colectat pe,
-No. of prints,Nr. De amprente,
-Number of prints required for labelling the samples,Numărul de tipăriri necesare pentru etichetarea probelor,
-HLC-VTS-.YYYY.-,HLC-VTS-.YYYY.-,
-In Time,La timp,
-Out Time,Timp liber,
-Payroll Cost Center,Centru de salarizare,
-Approvers,Aprobatori,
-The first Approver in the list will be set as the default Approver.,Primul aprobator din listă va fi setat ca aprobator implicit.,
-Shift Request Approver,Aprobarea cererii de schimbare,
-PAN Number,Număr PAN,
-Provident Fund Account,Contul Fondului Provident,
-MICR Code,Cod MICR,
-Repay unclaimed amount from salary,Rambursați suma nepreluată din salariu,
-Deduction from salary,Deducerea din salariu,
-Expired Leaves,Frunze expirate,
-Reference No,Nr. De referință,
-Haircut percentage is the percentage difference between market value of the Loan Security and the value ascribed to that Loan Security when used as collateral for that loan.,Procentul de tunsoare este diferența procentuală dintre valoarea de piață a titlului de împrumut și valoarea atribuită respectivului titlu de împrumut atunci când este utilizat ca garanție pentru împrumutul respectiv.,
-Loan To Value Ratio expresses the ratio of the loan amount to the value of the security pledged. A loan security shortfall will be triggered if this falls below the specified value for any loan ,Raportul împrumut la valoare exprimă raportul dintre suma împrumutului și valoarea garanției gajate. O deficiență a garanției împrumutului va fi declanșată dacă aceasta scade sub valoarea specificată pentru orice împrumut,
-If this is not checked the loan by default will be considered as a Demand Loan,"Dacă acest lucru nu este verificat, împrumutul implicit va fi considerat un împrumut la cerere",
-This account is used for booking loan repayments from the borrower and also disbursing loans to the borrower,"Acest cont este utilizat pentru rezervarea rambursărilor de împrumut de la împrumutat și, de asemenea, pentru a plăti împrumuturi către împrumutat",
-This account is capital account which is used to allocate capital for loan disbursal account ,Acest cont este un cont de capital care este utilizat pentru alocarea de capital pentru contul de debursare a împrumutului,
-This account will be used for booking loan interest accruals,Acest cont va fi utilizat pentru rezervarea dobânzilor la dobândă de împrumut,
-This account will be used for booking penalties levied due to delayed repayments,Acest cont va fi utilizat pentru rezervarea penalităților percepute din cauza rambursărilor întârziate,
-Variant BOM,Varianta DOM,
-Template Item,Articol șablon,
-Select template item,Selectați elementul șablon,
-Select variant item code for the template item {0},Selectați varianta codului articolului pentru elementul șablon {0},
-Downtime Entry,Intrare în timp de inactivitate,
-DT-,DT-,
-Workstation / Machine,Stație de lucru / Mașină,
-Operator,Operator,
-In Mins,În minele,
-Downtime Reason,Motivul opririi,
-Stop Reason,Stop Reason,
-Excessive machine set up time,Timp excesiv de configurare a mașinii,
-Unplanned machine maintenance,Întreținerea neplanificată a mașinii,
-On-machine press checks,Verificări de presă la mașină,
-Machine operator errors,Erori operator operator,
-Machine malfunction,Funcționarea defectuoasă a mașinii,
-Electricity down,Electricitate scăzută,
-Operation Row Number,Număr rând operațiune,
-Operation {0} added multiple times in the work order {1},Operația {0} adăugată de mai multe ori în ordinea de lucru {1},
-"If ticked, multiple materials can be used for a single Work Order. This is useful if one or more time consuming products are being manufactured.","Dacă este bifat, mai multe materiale pot fi utilizate pentru o singură comandă de lucru. Acest lucru este util dacă sunt fabricate unul sau mai multe produse consumatoare de timp.",
-Backflush Raw Materials,Materii prime Backflush,
-"The Stock Entry of type 'Manufacture' is known as backflush. Raw materials being consumed to manufacture finished goods is known as backflushing. <br><br> When creating Manufacture Entry, raw-material items are backflushed based on BOM of production item. If you want raw-material items to be backflushed based on Material Transfer entry made against that Work Order instead, then you can set it under this field.","Intrarea în stoc a tipului „Fabricare” este cunoscută sub numele de backflush. Materiile prime consumate pentru fabricarea produselor finite sunt cunoscute sub numele de backflushing.<br><br> La crearea intrării în fabricație, articolele din materie primă sunt revocate pe baza BOM a articolului de producție. Dacă doriți ca elementele din materie primă să fie revocate în funcție de intrarea de transfer de materiale efectuată împotriva respectivei comenzi de lucru, atunci o puteți seta în acest câmp.",
-Work In Progress Warehouse,Depozit Work In Progress,
-This Warehouse will be auto-updated in the Work In Progress Warehouse field of Work Orders.,Acest depozit va fi actualizat automat în câmpul Depozit de lucru în curs al comenzilor de lucru.,
-Finished Goods Warehouse,Depozit de produse finite,
-This Warehouse will be auto-updated in the Target Warehouse field of Work Order.,Acest depozit va fi actualizat automat în câmpul Depozit țintă din Ordinul de lucru.,
-"If ticked, the BOM cost will be automatically updated based on Valuation Rate / Price List Rate / last purchase rate of raw materials.","Dacă este bifat, costul BOM va fi actualizat automat în funcție de rata de evaluare / rata de listă de prețuri / ultima rată de achiziție a materiilor prime.",
-Source Warehouses (Optional),Depozite sursă (opțional),
-"System will pickup the materials from the selected warehouses. If not specified, system will create material request for purchase.","Sistemul va prelua materialele din depozitele selectate. Dacă nu este specificat, sistemul va crea o cerere materială pentru cumpărare.",
-Lead Time,Perioada de grație,
-PAN Details,Detalii PAN,
-Create Customer,Creați client,
-Invoicing,Facturare,
-Enable Auto Invoicing,Activați facturarea automată,
-Send Membership Acknowledgement,Trimiteți confirmarea de membru,
-Send Invoice with Email,Trimiteți factura prin e-mail,
-Membership Print Format,Formatul de tipărire a calității de membru,
-Invoice Print Format,Format de imprimare factură,
-Revoke <Key></Key>,Revoca&lt;Key&gt;&lt;/Key&gt;,
-You can learn more about memberships in the manual. ,Puteți afla mai multe despre abonamente în manual.,
-ERPNext Docs,Documente ERPNext,
-Regenerate Webhook Secret,Regenerați secretul Webhook,
-Generate Webhook Secret,Generați Webhook Secret,
-Copy Webhook URL,Copiați adresa URL Webhook,
-Linked Item,Element conectat,
-Is Recurring,Este recurent,
-HRA Exemption,Scutire HRA,
-Monthly House Rent,Închirierea lunară a casei,
-Rented in Metro City,Închiriat în Metro City,
-HRA as per Salary Structure,HRA conform structurii salariale,
-Annual HRA Exemption,Scutire anuală HRA,
-Monthly HRA Exemption,Scutire HRA lunară,
-House Rent Payment Amount,Suma plății chiriei casei,
-Rented From Date,Închiriat de la Data,
-Rented To Date,Închiriat până în prezent,
-Monthly Eligible Amount,Suma eligibilă lunară,
-Total Eligible HRA Exemption,Scutire HRA eligibilă totală,
-Validating Employee Attendance...,Validarea prezenței angajaților ...,
-Submitting Salary Slips and creating Journal Entry...,Trimiterea fișelor salariale și crearea intrării în jurnal ...,
-Calculate Payroll Working Days Based On,Calculați zilele lucrătoare de salarizare pe baza,
-Consider Unmarked Attendance As,Luați în considerare participarea nemarcată ca,
-Fraction of Daily Salary for Half Day,Fracțiunea salariului zilnic pentru jumătate de zi,
-Component Type,Tipul componentei,
-Provident Fund,Fondul Provident,
-Additional Provident Fund,Fondul Provident suplimentar,
-Provident Fund Loan,Împrumut pentru Fondul Provident,
-Professional Tax,Impozit profesional,
-Is Income Tax Component,Este componenta impozitului pe venit,
-Component properties and references ,Proprietăți și referințe ale componentelor,
-Additional Salary ,Salariu suplimentar,
-Unmarked days,Zile nemarcate,
-Absent Days,Zile absente,
-Conditions and Formula variable and example,Condiții și variabilă Formula și exemplu,
-Feedback By,Feedback de,
-Manufacturing Section,Secțiunea de fabricație,
-"By default, the Customer Name is set as per the Full Name entered. If you want Customers to be named by a ","În mod implicit, Numele clientului este setat conform Numelui complet introdus. Dacă doriți ca clienții să fie numiți de un",
-Configure the default Price List when creating a new Sales transaction. Item prices will be fetched from this Price List.,Configurați lista de prețuri implicită atunci când creați o nouă tranzacție de vânzări. Prețurile articolelor vor fi preluate din această listă de prețuri.,
-"If this option is configured 'Yes', ERPNext will prevent you from creating a Sales Invoice or Delivery Note without creating a Sales Order first. This configuration can be overridden for a particular Customer by enabling the 'Allow Sales Invoice Creation Without Sales Order' checkbox in the Customer master.","Dacă această opțiune este configurată „Da”, ERPNext vă va împiedica să creați o factură de vânzare sau o notă de livrare fără a crea mai întâi o comandă de vânzare. Această configurație poate fi anulată pentru un anumit Client activând caseta de selectare „Permite crearea facturii de vânzare fără comandă de vânzare” din masterul Clientului.",
-"If this option is configured 'Yes', ERPNext will prevent you from creating a Sales Invoice without creating a Delivery Note first. This configuration can be overridden for a particular Customer by enabling the 'Allow Sales Invoice Creation Without Delivery Note' checkbox in the Customer master.","Dacă această opțiune este configurată „Da”, ERPNext vă va împiedica să creați o factură de vânzare fără a crea mai întâi o notă de livrare. Această configurație poate fi suprascrisă pentru un anumit Client activând caseta de selectare „Permite crearea facturilor de vânzare fără notă de livrare” din masterul Clientului.",
-Default Warehouse for Sales Return,Depozit implicit pentru returnarea vânzărilor,
-Default In Transit Warehouse,Implicit în Depozitul de tranzit,
-Enable Perpetual Inventory For Non Stock Items,Activați inventarul perpetuu pentru articolele fără stoc,
-HRA Settings,Setări HRA,
-Basic Component,Componenta de bază,
-HRA Component,Componenta HRA,
-Arrear Component,Componenta Arrear,
-Please enter the company name to confirm,Vă rugăm să introduceți numele companiei pentru a confirma,
-Quotation Lost Reason Detail,Citat Detaliu motiv pierdut,
-Enable Variants,Activați variantele,
-Save Quotations as Draft,Salvați ofertele ca schiță,
-MAT-DN-RET-.YYYY.-,MAT-DN-RET-.YYYY.-,
-Please Select a Customer,Vă rugăm să selectați un client,
-Against Delivery Note Item,Împotriva articolului Note de livrare,
-Is Non GST ,Nu este GST,
-Image Description,Descrierea imaginii,
-Transfer Status,Stare transfer,
-MAT-PR-RET-.YYYY.-,MAT-PR-RET-.YYYY.-,
-Track this Purchase Receipt against any Project,Urmăriți această chitanță de cumpărare împotriva oricărui proiect,
-Please Select a Supplier,Vă rugăm să selectați un furnizor,
-Add to Transit,Adăugați la tranzit,
-Set Basic Rate Manually,Setați manual rata de bază,
-"By default, the Item Name is set as per the Item Code entered. If you want Items to be named by a ","În mod implicit, numele articolului este setat conform codului articolului introdus. Dacă doriți ca elementele să fie denumite de un",
-Set a Default Warehouse for Inventory Transactions. This will be fetched into the Default Warehouse in the Item master.,Setați un depozit implicit pentru tranzacțiile de inventar. Acest lucru va fi preluat în Depozitul implicit din elementul master.,
-"This will allow stock items to be displayed in negative values. Using this option depends on your use case. With this option unchecked, the system warns before obstructing a transaction that is causing negative stock.","Acest lucru va permite afișarea articolelor stoc în valori negative. Utilizarea acestei opțiuni depinde de cazul dvs. de utilizare. Cu această opțiune bifată, sistemul avertizează înainte de a obstrucționa o tranzacție care cauzează stoc negativ.",
-Choose between FIFO and Moving Average Valuation Methods. Click ,Alegeți între FIFO și metodele de evaluare medie mobile. Clic,
- to know more about them.,să afle mai multe despre ele.,
-Show 'Scan Barcode' field above every child table to insert Items with ease.,Afișați câmpul „Scanare cod de bare” deasupra fiecărui tabel copil pentru a insera articole cu ușurință.,
-"Serial numbers for stock will be set automatically based on the Items entered based on first in first out in transactions like Purchase/Sales Invoices, Delivery Notes, etc.","Numerele de serie pentru stoc vor fi setate automat pe baza articolelor introduse pe baza primelor în primele ieșiri din tranzacții precum facturi de cumpărare / vânzare, note de livrare etc.",
-"If blank, parent Warehouse Account or company default will be considered in transactions","Dacă este necompletat, contul de depozit părinte sau prestabilitatea companiei vor fi luate în considerare în tranzacții",
-Service Level Agreement Details,Detalii acord nivel de serviciu,
-Service Level Agreement Status,Starea Acordului la nivel de serviciu,
-On Hold Since,În așteptare de când,
-Total Hold Time,Timp total de așteptare,
-Response Details,Detalii de răspuns,
-Average Response Time,Timpul mediu de răspuns,
-User Resolution Time,Ora de rezoluție a utilizatorului,
-SLA is on hold since {0},SLA este în așteptare de la {0},
-Pause SLA On Status,Întrerupeți SLA On Status,
-Pause SLA On,Întrerupeți SLA Activat,
-Greetings Section,Secțiunea Salutări,
-Greeting Title,Titlu de salut,
-Greeting Subtitle,Subtitrare de salut,
-Youtube ID,ID YouTube,
-Youtube Statistics,Statistici Youtube,
-Views,Vizualizări,
-Dislikes,Nu-mi place,
-Video Settings,Setari video,
-Enable YouTube Tracking,Activați urmărirea YouTube,
-30 mins,30 de minute,
-1 hr,1 oră,
-6 hrs,6 ore,
-Patient Progress,Progresul pacientului,
-Targetted,Țintit,
-Score Obtained,Scor obținut,
-Sessions,Sesiuni,
-Average Score,Scor mediu,
-Select Assessment Template,Selectați Șablon de evaluare,
- out of ,din,
-Select Assessment Parameter,Selectați Parametru de evaluare,
-Gender: ,Gen:,
-Contact: ,A lua legatura:,
-Total Therapy Sessions: ,Total sesiuni de terapie:,
-Monthly Therapy Sessions: ,Sesiuni lunare de terapie:,
-Patient Profile,Profilul pacientului,
-Point Of Sale,Punct de vânzare,
-Email sent successfully.,Email-ul a fost trimis cu succes.,
-Search by invoice id or customer name,Căutați după ID-ul facturii sau numele clientului,
-Invoice Status,Starea facturii,
-Filter by invoice status,Filtrează după starea facturii,
-Select item group,Selectați grupul de articole,
-No items found. Scan barcode again.,Nu au fost gasite articolele. Scanați din nou codul de bare.,
-"Search by customer name, phone, email.","Căutare după numele clientului, telefon, e-mail.",
-Enter discount percentage.,Introduceți procentul de reducere.,
-Discount cannot be greater than 100%,Reducerea nu poate fi mai mare de 100%,
-Enter customer's email,Introduceți adresa de e-mail a clientului,
-Enter customer's phone number,Introduceți numărul de telefon al clientului,
-Customer contact updated successfully.,Contactul clientului a fost actualizat cu succes.,
-Item will be removed since no serial / batch no selected.,Elementul va fi eliminat deoarece nu este selectat niciun serial / lot.,
-Discount (%),Reducere (%),
-You cannot submit the order without payment.,Nu puteți trimite comanda fără plată.,
-You cannot submit empty order.,Nu puteți trimite o comandă goală.,
-To Be Paid,A fi platit,
-Create POS Opening Entry,Creați o intrare de deschidere POS,
-Please add Mode of payments and opening balance details.,Vă rugăm să adăugați detalii despre modul de plată și soldul de deschidere.,
-Toggle Recent Orders,Comutați comenzile recente,
-Save as Draft,Salvează ca ciornă,
-You must add atleast one item to save it as draft.,Trebuie să adăugați cel puțin un articol pentru al salva ca schiță.,
-There was an error saving the document.,A apărut o eroare la salvarea documentului.,
-You must select a customer before adding an item.,Trebuie să selectați un client înainte de a adăuga un articol.,
-Please Select a Company,Vă rugăm să selectați o companie,
-Active Leads,Oportunități active,
-Please Select a Company.,Vă rugăm să selectați o companie.,
-BOM Operations Time,Timp operații BOM,
-BOM ID,ID-ul BOM,
-BOM Item Code,Cod articol BOM,
-Time (In Mins),Timp (în minute),
-Sub-assembly BOM Count,Numărul BOM al subansamblului,
-View Type,Tipul de vizualizare,
-Total Delivered Amount,Suma totală livrată,
-Downtime Analysis,Analiza timpului de oprire,
-Machine,Mașinărie,
-Downtime (In Hours),Timp de inactivitate (în ore),
-Employee Analytics,Analiza angajaților,
-"""From date"" can not be greater than or equal to ""To date""",„De la dată” nu poate fi mai mare sau egal cu „Până în prezent”,
-Exponential Smoothing Forecasting,Previziune de netezire exponențială,
-First Response Time for Issues,Primul timp de răspuns pentru probleme,
-First Response Time for Opportunity,Primul timp de răspuns pentru oportunitate,
-Depreciatied Amount,Suma depreciată,
-Period Based On,Perioada bazată pe,
-Date Based On,Data bazată pe,
-{0} and {1} are mandatory,{0} și {1} sunt obligatorii,
-Consider Accounting Dimensions,Luați în considerare dimensiunile contabile,
-Income Tax Deductions,Deduceri de impozit pe venit,
-Income Tax Component,Componenta impozitului pe venit,
-Income Tax Amount,Suma impozitului pe venit,
-Reserved Quantity for Production,Cantitate rezervată pentru producție,
-Projected Quantity,Cantitatea proiectată,
- Total Sales Amount,Suma totală a vânzărilor,
-Job Card Summary,Rezumatul fișei de muncă,
-Id,Id,
-Time Required (In Mins),Timp necesar (în minute),
-From Posting Date,De la data înregistrării,
-To Posting Date,Până la data de înregistrare,
-No records found,Nu au fost găsite,
-Customer/Lead Name,Numele clientului / clientului,
-Unmarked Days,Zile nemarcate,
-Jan,Ian,
-Feb,Februarie,
-Mar,Mar,
-Apr,Aprilie,
-Aug,Aug,
-Sep,Sept,
-Oct,Oct,
-Nov,Noiembrie,
-Dec,Dec,
-Summarized View,Vizualizare rezumată,
-Production Planning Report,Raport de planificare a producției,
-Order Qty,Comandați cantitatea,
-Raw Material Code,Codul materiei prime,
-Raw Material Name,Numele materiei prime,
-Allotted Qty,Cantitate alocată,
-Expected Arrival Date,Data de sosire preconizată,
-Arrival Quantity,Cantitatea de sosire,
-Raw Material Warehouse,Depozit de materii prime,
-Order By,Comandați după,
-Include Sub-assembly Raw Materials,Includeți subansamblarea materiilor prime,
-Professional Tax Deductions,Deduceri fiscale profesionale,
-Program wise Fee Collection,Colectarea taxelor în funcție de program,
-Fees Collected,Taxe colectate,
-Project Summary,Sumarul proiectului,
-Total Tasks,Total sarcini,
-Tasks Completed,Sarcini finalizate,
-Tasks Overdue,Sarcini restante,
-Completion,Completare,
-Provident Fund Deductions,Deduceri din fondul Provident,
-Purchase Order Analysis,Analiza comenzii de cumpărare,
-From and To Dates are required.,De la și până la date sunt necesare.,
-To Date cannot be before From Date.,To Date nu poate fi înainte de From Date.,
-Qty to Bill,Cantitate pentru Bill,
-Group by Purchase Order,Grupați după ordinul de cumpărare,
- Purchase Value,Valoare de cumpărare,
-Total Received Amount,Suma totală primită,
-Quality Inspection Summary,Rezumatul inspecției calității,
- Quoted Amount,Suma citată,
-Lead Time (Days),Timp de plumb (zile),
-Include Expired,Includeți Expirat,
-Recruitment Analytics,Analize de recrutare,
-Applicant name,Numele solicitantului,
-Job Offer status,Starea ofertei de muncă,
-On Date,La întălnire,
-Requested Items to Order and Receive,Articolele solicitate la comandă și primire,
-Salary Payments Based On Payment Mode,Plăți salariale bazate pe modul de plată,
-Salary Payments via ECS,Plăți salariale prin ECS,
-Account No,Cont nr,
-IFSC,IFSC,
-MICR,MICR,
-Sales Order Analysis,Analiza comenzilor de vânzare,
-Amount Delivered,Suma livrată,
-Delay (in Days),Întârziere (în zile),
-Group by Sales Order,Grupați după comanda de vânzare,
- Sales Value,Valoarea vânzărilor,
-Stock Qty vs Serial No Count,Cantitate stoc vs număr fără serie,
-Serial No Count,Număr de serie,
-Work Order Summary,Rezumatul comenzii de lucru,
-Produce Qty,Produceți cantitatea,
-Lead Time (in mins),Durata de livrare (în minute),
-Charts Based On,Diagramele bazate pe,
-YouTube Interactions,Interacțiuni YouTube,
-Published Date,Data publicării,
-Barnch,Barnch,
-Select a Company,Selectați o companie,
-Opportunity {0} created,Oportunitate {0} creată,
-Kindly select the company first,Vă rugăm să selectați mai întâi compania,
-Please enter From Date and To Date to generate JSON,Vă rugăm să introduceți De la dată și până la data pentru a genera JSON,
-PF Account,Cont PF,
-PF Amount,Suma PF,
-Additional PF,PF suplimentar,
-PF Loan,Împrumut PF,
-Download DATEV File,Descărcați fișierul DATEV,
-Numero has not set in the XML file,Numero nu a fost setat în fișierul XML,
-Inward Supplies(liable to reverse charge),Consumabile interne (susceptibile de a inversa taxa),
-This is based on the course schedules of this Instructor,Aceasta se bazează pe programele de curs ale acestui instructor,
-Course and Assessment,Curs și evaluare,
-Course {0} has been added to all the selected programs successfully.,Cursul {0} a fost adăugat cu succes la toate programele selectate.,
-Programs updated,Programe actualizate,
-Program and Course,Program și curs,
-{0} or {1} is mandatory,{0} sau {1} este obligatoriu,
-Mandatory Fields,Câmpuri obligatorii,
-Student {0}: {1} does not belong to Student Group {2},Student {0}: {1} nu aparține grupului de studenți {2},
-Student Attendance record {0} already exists against the Student {1},Înregistrarea prezenței studenților {0} există deja împotriva studentului {1},
-Duplicate Entry,Intrare duplicat,
-Course and Fee,Curs și Taxă,
-Not eligible for the admission in this program as per Date Of Birth,Nu este eligibil pentru admiterea în acest program conform datei nașterii,
-Topic {0} has been added to all the selected courses successfully.,Subiectul {0} a fost adăugat cu succes la toate cursurile selectate.,
-Courses updated,Cursuri actualizate,
-{0} {1} has been added to all the selected topics successfully.,{0} {1} a fost adăugat cu succes la toate subiectele selectate.,
-Topics updated,Subiecte actualizate,
-Academic Term and Program,Termen academic și program,
-Please remove this item and try to submit again or update the posting time.,Eliminați acest articol și încercați să trimiteți din nou sau să actualizați ora de postare.,
-Failed to Authenticate the API key.,Autentificarea cheii API nu a reușit.,
-Invalid Credentials,Acreditări nevalide,
-URL can only be a string,Adresa URL poate fi doar un șir,
-"Here is your webhook secret, this will be shown to you only once.","Iată secretul tău webhook, acesta îți va fi afișat o singură dată.",
-The payment for this membership is not paid. To generate invoice fill the payment details,Plata pentru acest membru nu este plătită. Pentru a genera factura completați detaliile de plată,
-An invoice is already linked to this document,O factură este deja legată de acest document,
-No customer linked to member {},Niciun client legat de membru {},
-You need to set <b>Debit Account</b> in Membership Settings,Trebuie să setați <b>Cont de debit</b> în Setări de membru,
-You need to set <b>Default Company</b> for invoicing in Membership Settings,Trebuie să setați <b>Compania implicită</b> pentru facturare în Setări de membru,
-You need to enable <b>Send Acknowledge Email</b> in Membership Settings,Trebuie să activați <b>Trimitere e-mail de confirmare</b> în setările de membru,
-Error creating membership entry for {0},Eroare la crearea intrării de membru pentru {0},
-A customer is already linked to this Member,Un client este deja legat de acest membru,
-End Date must not be lesser than Start Date,Data de încheiere nu trebuie să fie mai mică decât Data de începere,
-Employee {0} already has Active Shift {1}: {2},Angajatul {0} are deja Active Shift {1}: {2},
- from {0},de la {0},
- to {0},către {0},
-Please select Employee first.,Vă rugăm să selectați mai întâi Angajat.,
-Please set {0} for the Employee or for Department: {1},Vă rugăm să setați {0} pentru angajat sau pentru departament: {1},
-To Date should be greater than From Date,To Date ar trebui să fie mai mare decât From Date,
-Employee Onboarding: {0} is already for Job Applicant: {1},Integrarea angajaților: {0} este deja pentru solicitantul de post: {1},
-Job Offer: {0} is already for Job Applicant: {1},Ofertă de locuri de muncă: {0} este deja pentru solicitantul de post: {1},
-Only Shift Request with status 'Approved' and 'Rejected' can be submitted,Numai cererea Shift cu starea „Aprobat” și „Respins” poate fi trimisă,
-Shift Assignment: {0} created for Employee: {1},Atribuire schimbare: {0} creată pentru angajat: {1},
-You can not request for your Default Shift: {0},Nu puteți solicita schimbarea implicită: {0},
-Only Approvers can Approve this Request.,Numai aprobatorii pot aproba această solicitare.,
-Asset Value Analytics,Analiza valorii activelor,
-Category-wise Asset Value,Valoarea activelor în funcție de categorie,
-Total Assets,Total active,
-New Assets (This Year),Active noi (anul acesta),
-Row #{}: Depreciation Posting Date should not be equal to Available for Use Date.,Rândul {{}: Data de înregistrare a amortizării nu trebuie să fie egală cu Disponibil pentru data de utilizare.,
-Incorrect Date,Data incorectă,
-Invalid Gross Purchase Amount,Suma brută de achiziție nevalidă,
-There are active maintenance or repairs against the asset. You must complete all of them before cancelling the asset.,Există activități de întreținere sau reparații active asupra activului. Trebuie să le completați pe toate înainte de a anula activul.,
-% Complete,% Complet,
-Back to Course,Înapoi la curs,
-Finish Topic,Finalizați subiectul,
-Mins,Min,
-by,de,
-Back to,Înapoi la,
-Enrolling...,Se înscrie ...,
-You have successfully enrolled for the program ,V-ați înscris cu succes la program,
-Enrolled,Înscris,
-Watch Intro,Urmăriți Introducere,
-We're here to help!,Suntem aici pentru a vă ajuta!,
-Frequently Read Articles,Citiți frecvent articole,
-Please set a default company address,Vă rugăm să setați o adresă implicită a companiei,
-{0} is not a valid state! Check for typos or enter the ISO code for your state.,{0} nu este o stare validă! Verificați dacă există greșeli sau introduceți codul ISO pentru starea dvs.,
-Error occured while parsing Chart of Accounts: Please make sure that no two accounts have the same name,A apărut o eroare la analizarea planului de conturi: asigurați-vă că niciun cont nu are același nume,
-Plaid invalid request error,Eroare solicitare invalidă în carouri,
-Please check your Plaid client ID and secret values,Vă rugăm să verificați ID-ul dvs. de client Plaid și valorile secrete,
-Bank transaction creation error,Eroare la crearea tranzacțiilor bancare,
-Unit of Measurement,Unitate de măsură,
-Fiscal Year {0} Does Not Exist,Anul fiscal {0} nu există,
-Row # {0}: Returned Item {1} does not exist in {2} {3},Rândul # {0}: articolul returnat {1} nu există în {2} {3},
-Valuation type charges can not be marked as Inclusive,Taxele de tip de evaluare nu pot fi marcate ca Incluse,
-You do not have permissions to {} items in a {}.,Nu aveți permisiuni pentru {} articole dintr-un {}.,
-Insufficient Permissions,Permisiuni insuficiente,
-You are not allowed to update as per the conditions set in {} Workflow.,Nu aveți permisiunea de a actualiza conform condițiilor stabilite în {} Workflow.,
-Expense Account Missing,Cont de cheltuieli lipsește,
-{0} is not a valid Value for Attribute {1} of Item {2}.,{0} nu este o valoare validă pentru atributul {1} al articolului {2}.,
-Invalid Value,Valoare invalida,
-The value {0} is already assigned to an existing Item {1}.,Valoarea {0} este deja alocată unui articol existent {1}.,
-"To still proceed with editing this Attribute Value, enable {0} in Item Variant Settings.","Pentru a continua să editați această valoare a atributului, activați {0} în Setări pentru varianta articolului.",
-Edit Not Allowed,Editarea nu este permisă,
-Row #{0}: Item {1} is already fully received in Purchase Order {2},Rândul nr. {0}: Articolul {1} este deja complet primit în Comanda de cumpărare {2},
-You cannot create or cancel any accounting entries with in the closed Accounting Period {0},Nu puteți crea sau anula nicio înregistrare contabilă în perioada de contabilitate închisă {0},
-POS Invoice should have {} field checked.,Factura POS ar trebui să aibă selectat câmpul {}.,
-Invalid Item,Element nevalid,
-Row #{}: You cannot add postive quantities in a return invoice. Please remove item {} to complete the return.,Rândul # {}: nu puteți adăuga cantități postive într-o factură de returnare. Eliminați articolul {} pentru a finaliza returnarea.,
-The selected change account {} doesn't belongs to Company {}.,Contul de modificare selectat {} nu aparține companiei {}.,
-Atleast one invoice has to be selected.,Trebuie selectată cel puțin o factură.,
-Payment methods are mandatory. Please add at least one payment method.,Metodele de plată sunt obligatorii. Vă rugăm să adăugați cel puțin o metodă de plată.,
-Please select a default mode of payment,Vă rugăm să selectați un mod de plată implicit,
-You can only select one mode of payment as default,Puteți selecta doar un mod de plată ca prestabilit,
-Missing Account,Cont lipsă,
-Customers not selected.,Clienții nu sunt selectați.,
-Statement of Accounts,Declarație de conturi,
-Ageing Report Based On ,Raport de îmbătrânire bazat pe,
-Please enter distributed cost center,Vă rugăm să introduceți centrul de cost distribuit,
-Total percentage allocation for distributed cost center should be equal to 100,Alocarea procentuală totală pentru centrul de cost distribuit ar trebui să fie egală cu 100,
-Cannot enable Distributed Cost Center for a Cost Center already allocated in another Distributed Cost Center,Nu se poate activa Centrul de costuri distribuite pentru un centru de costuri deja alocat într-un alt centru de costuri distribuite,
-Parent Cost Center cannot be added in Distributed Cost Center,Centrul de costuri părinte nu poate fi adăugat în Centrul de costuri distribuite,
-A Distributed Cost Center cannot be added in the Distributed Cost Center allocation table.,Un centru de costuri distribuite nu poate fi adăugat în tabelul de alocare a centrului de costuri distribuite.,
-Cost Center with enabled distributed cost center can not be converted to group,Centrul de costuri cu centrul de costuri distribuite activat nu poate fi convertit în grup,
-Cost Center Already Allocated in a Distributed Cost Center cannot be converted to group,Centrul de cost deja alocat într-un centru de cost distribuit nu poate fi convertit în grup,
-Trial Period Start date cannot be after Subscription Start Date,Perioada de încercare Data de începere nu poate fi ulterioară datei de începere a abonamentului,
-Subscription End Date must be after {0} as per the subscription plan,Data de încheiere a abonamentului trebuie să fie după {0} conform planului de abonament,
-Subscription End Date is mandatory to follow calendar months,Data de încheiere a abonamentului este obligatorie pentru a urma lunile calendaristice,
-Row #{}: POS Invoice {} is not against customer {},Rândul # {}: factura POS {} nu este împotriva clientului {},
-Row #{}: POS Invoice {} is not submitted yet,Rândul # {}: factura POS {} nu a fost încă trimisă,
-Row #{}: POS Invoice {} has been {},Rândul # {}: factura POS {} a fost {},
-No Supplier found for Inter Company Transactions which represents company {0},Nu a fost găsit niciun furnizor pentru tranzacțiile între companii care să reprezinte compania {0},
-No Customer found for Inter Company Transactions which represents company {0},Nu a fost găsit niciun client pentru tranzacțiile între companii care reprezintă compania {0},
-Invalid Period,Perioadă nevalidă,
-Selected POS Opening Entry should be open.,Intrarea selectată de deschidere POS ar trebui să fie deschisă.,
-Invalid Opening Entry,Intrare de deschidere nevalidă,
-Please set a Company,Vă rugăm să setați o companie,
-"Sorry, this coupon code's validity has not started","Ne pare rău, valabilitatea acestui cod cupon nu a început",
-"Sorry, this coupon code's validity has expired","Ne pare rău, valabilitatea acestui cod de cupon a expirat",
-"Sorry, this coupon code is no longer valid","Ne pare rău, acest cod de cupon nu mai este valid",
-For the 'Apply Rule On Other' condition the field {0} is mandatory,"Pentru condiția „Aplică regula la altele”, câmpul {0} este obligatoriu",
-{1} Not in Stock,{1} Nu este în stoc,
-Only {0} in Stock for item {1},Numai {0} în stoc pentru articolul {1},
-Please enter a coupon code,Vă rugăm să introduceți un cod de cupon,
-Please enter a valid coupon code,Vă rugăm să introduceți un cod de cupon valid,
-Invalid Child Procedure,Procedură copil nevalidă,
-Import Italian Supplier Invoice.,Importați factura furnizorului italian.,
-"Valuation Rate for the Item {0}, is required to do accounting entries for {1} {2}.","Rata de evaluare pentru articolul {0}, este necesară pentru a face înregistrări contabile pentru {1} {2}.",
- Here are the options to proceed:,Iată opțiunile pentru a continua:,
-"If the item is transacting as a Zero Valuation Rate item in this entry, please enable 'Allow Zero Valuation Rate' in the {0} Item table.","Dacă articolul tranzacționează ca articol cu o rată de evaluare zero în această intrare, activați „Permiteți o rată de evaluare zero” în tabelul {0} Articol.",
-"If not, you can Cancel / Submit this entry ","Dacă nu, puteți anula / trimite această intrare",
- performing either one below:,efectuând una dintre cele de mai jos:,
-Create an incoming stock transaction for the Item.,Creați o tranzacție de stoc primită pentru articol.,
-Mention Valuation Rate in the Item master.,Menționați rata de evaluare în elementul master.,
-Valuation Rate Missing,Rata de evaluare lipsește,
-Serial Nos Required,Numere de serie necesare,
-Quantity Mismatch,Cantitate necorespunzătoare,
-"Please Restock Items and Update the Pick List to continue. To discontinue, cancel the Pick List.","Vă rugăm să reporniți articolele și să actualizați lista de alegeri pentru a continua. Pentru a întrerupe, anulați lista de alegeri.",
-Out of Stock,Stoc epuizat,
-{0} units of Item {1} is not available.,{0} unități de articol {1} nu sunt disponibile.,
-Item for row {0} does not match Material Request,Elementul pentru rândul {0} nu se potrivește cu Cererea de material,
-Warehouse for row {0} does not match Material Request,Depozitul pentru rândul {0} nu se potrivește cu Cererea de material,
-Accounting Entry for Service,Intrare contabilă pentru service,
-All items have already been Invoiced/Returned,Toate articolele au fost deja facturate / returnate,
-All these items have already been Invoiced/Returned,Toate aceste articole au fost deja facturate / returnate,
-Stock Reconciliations,Reconcilieri stocuri,
-Merge not allowed,Îmbinarea nu este permisă,
-The following deleted attributes exist in Variants but not in the Template. You can either delete the Variants or keep the attribute(s) in template.,"Următoarele atribute șterse există în variante, dar nu în șablon. Puteți șterge variantele sau puteți păstra atributele în șablon.",
-Variant Items,Elemente variante,
-Variant Attribute Error,Eroare a atributului variantei,
-The serial no {0} does not belong to item {1},Numărul de serie {0} nu aparține articolului {1},
-There is no batch found against the {0}: {1},Nu există niciun lot găsit împotriva {0}: {1},
-Completed Operation,Operațiune finalizată,
-Work Order Analysis,Analiza comenzii de lucru,
-Quality Inspection Analysis,Analiza inspecției calității,
-Pending Work Order,Ordin de lucru în așteptare,
-Last Month Downtime Analysis,Analiza timpului de nefuncționare de luna trecută,
-Work Order Qty Analysis,Analiza cantității comenzii de lucru,
-Job Card Analysis,Analiza fișei de muncă,
-Monthly Total Work Orders,Comenzi lunare totale de lucru,
-Monthly Completed Work Orders,Comenzi de lucru finalizate lunar,
-Ongoing Job Cards,Carduri de muncă în curs,
-Monthly Quality Inspections,Inspecții lunare de calitate,
-(Forecast),(Prognoza),
-Total Demand (Past Data),Cerere totală (date anterioare),
-Total Forecast (Past Data),Prognoză totală (date anterioare),
-Total Forecast (Future Data),Prognoză totală (date viitoare),
-Based On Document,Pe baza documentului,
-Based On Data ( in years ),Pe baza datelor (în ani),
-Smoothing Constant,Netezire constantă,
-Please fill the Sales Orders table,Vă rugăm să completați tabelul Comenzi de vânzare,
-Sales Orders Required,Sunt necesare comenzi de vânzare,
-Please fill the Material Requests table,Vă rugăm să completați tabelul Cereri de materiale,
-Material Requests Required,Cereri materiale necesare,
-Items to Manufacture are required to pull the Raw Materials associated with it.,Articolele de fabricație sunt necesare pentru a extrage materiile prime asociate acestuia.,
-Items Required,Elemente necesare,
-Operation {0} does not belong to the work order {1},Operația {0} nu aparține comenzii de lucru {1},
-Print UOM after Quantity,Imprimați UOM după Cantitate,
-Set default {0} account for perpetual inventory for non stock items,Setați contul {0} implicit pentru inventarul perpetuu pentru articolele care nu sunt în stoc,
-Loan Security {0} added multiple times,Securitatea împrumutului {0} adăugată de mai multe ori,
-Loan Securities with different LTV ratio cannot be pledged against one loan,Titlurile de împrumut cu un raport LTV diferit nu pot fi gajate împotriva unui singur împrumut,
-Qty or Amount is mandatory for loan security!,Cantitatea sau suma este obligatorie pentru securitatea împrumutului!,
-Only submittted unpledge requests can be approved,Numai cererile unpledge trimise pot fi aprobate,
-Interest Amount or Principal Amount is mandatory,Suma dobânzii sau suma principală este obligatorie,
-Disbursed Amount cannot be greater than {0},Suma plătită nu poate fi mai mare de {0},
-Row {0}: Loan Security {1} added multiple times,Rândul {0}: Securitatea împrumutului {1} adăugat de mai multe ori,
-Row #{0}: Child Item should not be a Product Bundle. Please remove Item {1} and Save,Rândul # {0}: articolul secundar nu trebuie să fie un pachet de produse. Eliminați articolul {1} și Salvați,
-Credit limit reached for customer {0},Limita de credit atinsă pentru clientul {0},
-Could not auto create Customer due to the following missing mandatory field(s):,Nu s-a putut crea automat Clientul din cauza următoarelor câmpuri obligatorii lipsă:,
-Please create Customer from Lead {0}.,Vă rugăm să creați Client din Lead {0}.,
-Mandatory Missing,Obligatoriu Lipsește,
-Please set Payroll based on in Payroll settings,Vă rugăm să setați salarizarea pe baza setărilor de salarizare,
-Additional Salary: {0} already exist for Salary Component: {1} for period {2} and {3},Salariu suplimentar: {0} există deja pentru componenta salariu: {1} pentru perioada {2} și {3},
-From Date can not be greater than To Date.,From Date nu poate fi mai mare decât To Date.,
-Payroll date can not be less than employee's joining date.,Data salarizării nu poate fi mai mică decât data aderării angajatului.,
-From date can not be less than employee's joining date.,De la data nu poate fi mai mică decât data aderării angajatului.,
-To date can not be greater than employee's relieving date.,Până în prezent nu poate fi mai mare decât data de eliberare a angajatului.,
-Payroll date can not be greater than employee's relieving date.,Data salarizării nu poate fi mai mare decât data de scutire a angajatului.,
-Row #{0}: Please enter the result value for {1},Rândul # {0}: introduceți valoarea rezultatului pentru {1},
-Mandatory Results,Rezultate obligatorii,
-Sales Invoice or Patient Encounter is required to create Lab Tests,Factura de vânzare sau întâlnirea pacientului sunt necesare pentru a crea teste de laborator,
-Insufficient Data,Date insuficiente,
-Lab Test(s) {0} created successfully,Testele de laborator {0} au fost create cu succes,
-Test :,Test :,
-Sample Collection {0} has been created,A fost creată colecția de probe {0},
-Normal Range: ,Gama normală:,
-Row #{0}: Check Out datetime cannot be less than Check In datetime,Rândul # {0}: data de check out nu poate fi mai mică decât data de check in,
-"Missing required details, did not create Inpatient Record","Lipsesc detaliile solicitate, nu s-a creat înregistrarea internată",
-Unbilled Invoices,Facturi nefacturate,
-Standard Selling Rate should be greater than zero.,Rata de vânzare standard ar trebui să fie mai mare decât zero.,
-Conversion Factor is mandatory,Factorul de conversie este obligatoriu,
-Row #{0}: Conversion Factor is mandatory,Rândul # {0}: factorul de conversie este obligatoriu,
-Sample Quantity cannot be negative or 0,Cantitatea eșantionului nu poate fi negativă sau 0,
-Invalid Quantity,Cantitate nevalidă,
-"Please set defaults for Customer Group, Territory and Selling Price List in Selling Settings","Vă rugăm să setați valorile implicite pentru grupul de clienți, teritoriu și lista de prețuri de vânzare din setările de vânzare",
-{0} on {1},{0} pe {1},
-{0} with {1},{0} cu {1},
-Appointment Confirmation Message Not Sent,Mesajul de confirmare a programării nu a fost trimis,
-"SMS not sent, please check SMS Settings","SMS-ul nu a fost trimis, verificați Setările SMS",
-Healthcare Service Unit Type cannot have both {0} and {1},"Tipul unității de servicii medicale nu poate avea atât {0}, cât și {1}",
-Healthcare Service Unit Type must allow atleast one among {0} and {1},Tipul unității de servicii medicale trebuie să permită cel puțin unul dintre {0} și {1},
-Set Response Time and Resolution Time for Priority {0} in row {1}.,Setați timpul de răspuns și timpul de rezoluție pentru prioritatea {0} în rândul {1}.,
-Response Time for {0} priority in row {1} can't be greater than Resolution Time.,Timpul de răspuns pentru {0} prioritatea în rândul {1} nu poate fi mai mare decât timpul de rezoluție.,
-{0} is not enabled in {1},{0} nu este activat în {1},
-Group by Material Request,Grupați după cerere de material,
-Email Sent to Supplier {0},E-mail trimis către furnizor {0},
-"The Access to Request for Quotation From Portal is Disabled. To Allow Access, Enable it in Portal Settings.","Accesul la cererea de ofertă de la portal este dezactivat. Pentru a permite accesul, activați-l în Setări portal.",
-Supplier Quotation {0} Created,Ofertă furnizor {0} creată,
-Valid till Date cannot be before Transaction Date,Valabil până la data nu poate fi înainte de data tranzacției,
-Unlink Advance Payment on Cancellation of Order,Deconectați plata în avans la anularea comenzii,
-"Simple Python Expression, Example: territory != 'All Territories'","Expresie simplă Python, Exemplu: teritoriu! = „Toate teritoriile”",
-Sales Contributions and Incentives,Contribuții la vânzări și stimulente,
-Sourced by Supplier,Aprovizionat de furnizor,
-Total weightage assigned should be 100%.<br>It is {0},Ponderea totală alocată ar trebui să fie de 100%.<br> Este {0},
-Account {0} exists in parent company {1}.,Contul {0} există în compania mamă {1}.,
-"To overrule this, enable '{0}' in company {1}","Pentru a ignora acest lucru, activați „{0}” în companie {1}",
-Invalid condition expression,Expresie de condiție nevalidă,
-Please Select a Company First,Vă rugăm să selectați mai întâi o companie,
-Please Select Both Company and Party Type First,"Vă rugăm să selectați mai întâi atât compania, cât și tipul de petrecere",
-Provide the invoice portion in percent,Furnizați partea de facturare în procente,
-Give number of days according to prior selection,Dați numărul de zile în funcție de selecția anterioară,
-Email Details,Detalii e-mail,
-"Select a greeting for the receiver. E.g. Mr., Ms., etc.","Selectați o felicitare pentru receptor. De exemplu, domnul, doamna etc.",
-Preview Email,Previzualizați e-mailul,
-Please select a Supplier,Vă rugăm să selectați un furnizor,
-Supplier Lead Time (days),Timp de livrare a furnizorului (zile),
-"Home, Work, etc.","Acasă, serviciu etc.",
-Exit Interview Held On,Ieșiți din interviu,
-Condition and formula,Stare și formulă,
-Sets 'Target Warehouse' in each row of the Items table.,Setează „Depozit țintă” în fiecare rând al tabelului Elemente.,
-Sets 'Source Warehouse' in each row of the Items table.,Setează „Depozit sursă” în fiecare rând al tabelului Elemente.,
-POS Register,Registrul POS,
-"Can not filter based on POS Profile, if grouped by POS Profile","Nu se poate filtra pe baza profilului POS, dacă este grupat după profilul POS",
-"Can not filter based on Customer, if grouped by Customer","Nu se poate filtra pe baza clientului, dacă este grupat după client",
-"Can not filter based on Cashier, if grouped by Cashier","Nu se poate filtra în funcție de Casier, dacă este grupat după Casier",
-Payment Method,Modalitate de plată,
-"Can not filter based on Payment Method, if grouped by Payment Method","Nu se poate filtra pe baza metodei de plată, dacă este grupată după metoda de plată",
-Supplier Quotation Comparison,Compararea ofertelor de ofertă,
-Price per Unit (Stock UOM),Preț per unitate (stoc UOM),
-Group by Supplier,Grup pe furnizor,
-Group by Item,Grupați după articol,
-Remember to set {field_label}. It is required by {regulation}.,Nu uitați să setați {field_label}. Este cerut de {regulament}.,
-Enrollment Date cannot be before the Start Date of the Academic Year {0},Data înscrierii nu poate fi înainte de data de începere a anului academic {0},
-Enrollment Date cannot be after the End Date of the Academic Term {0},Data înscrierii nu poate fi ulterioară datei de încheiere a termenului academic {0},
-Enrollment Date cannot be before the Start Date of the Academic Term {0},Data înscrierii nu poate fi anterioară datei de începere a termenului academic {0},
-Future Posting Not Allowed,Postarea viitoare nu este permisă,
-"To enable Capital Work in Progress Accounting, ","Pentru a permite contabilitatea activității de capital în curs,",
-you must select Capital Work in Progress Account in accounts table,trebuie să selectați Contul de capital în curs în tabelul de conturi,
-You can also set default CWIP account in Company {},"De asemenea, puteți seta contul CWIP implicit în Companie {}",
-The Request for Quotation can be accessed by clicking on the following button,Cererea de ofertă poate fi accesată făcând clic pe butonul următor,
-Regards,Salutari,
-Please click on the following button to set your new password,Vă rugăm să faceți clic pe următorul buton pentru a seta noua parolă,
-Update Password,Actualizați parola,
-Row #{}: Selling rate for item {} is lower than its {}. Selling {} should be atleast {},Rândul # {}: rata de vânzare a articolului {} este mai mică decât {}. Vânzarea {} ar trebui să fie cel puțin {},
-You can alternatively disable selling price validation in {} to bypass this validation.,Puteți dezactiva alternativ validarea prețului de vânzare în {} pentru a ocoli această validare.,
-Invalid Selling Price,Preț de vânzare nevalid,
-Address needs to be linked to a Company. Please add a row for Company in the Links table.,Adresa trebuie să fie legată de o companie. Vă rugăm să adăugați un rând pentru Companie în tabelul Legături.,
-Company Not Linked,Compania nu este legată,
-Import Chart of Accounts from CSV / Excel files,Importați planul de conturi din fișiere CSV / Excel,
-Completed Qty cannot be greater than 'Qty to Manufacture',Cantitatea completată nu poate fi mai mare decât „Cantitatea pentru fabricare”,
-"Row {0}: For Supplier {1}, Email Address is Required to send an email","Rândul {0}: pentru furnizor {1}, este necesară adresa de e-mail pentru a trimite un e-mail",
-"If enabled, the system will post accounting entries for inventory automatically","Dacă este activat, sistemul va înregistra automat înregistrări contabile pentru inventar",
-Accounts Frozen Till Date,Conturi congelate până la data,
-Accounting entries are frozen up to this date. Nobody can create or modify entries except users with the role specified below,"Înregistrările contabile sunt înghețate până la această dată. Nimeni nu poate crea sau modifica intrări, cu excepția utilizatorilor cu rolul specificat mai jos",
-Role Allowed to Set Frozen Accounts and Edit Frozen Entries,Rolul permis pentru setarea conturilor înghețate și editarea intrărilor înghețate,
-Address used to determine Tax Category in transactions,Adresa utilizată pentru determinarea categoriei fiscale în tranzacții,
-"The percentage you are allowed to bill more against the amount ordered. For example, if the order value is $100 for an item and tolerance is set as 10%, then you are allowed to bill up to $110 ","Procentul pe care vi se permite să îl facturați mai mult pentru suma comandată. De exemplu, dacă valoarea comenzii este de 100 USD pentru un articol și toleranța este setată la 10%, atunci aveți permisiunea de a factura până la 110 USD",
-This role is allowed to submit transactions that exceed credit limits,Acest rol este permis să trimită tranzacții care depășesc limitele de credit,
-"If ""Months"" is selected, a fixed amount will be booked as deferred revenue or expense for each month irrespective of the number of days in a month. It will be prorated if deferred revenue or expense is not booked for an entire month","Dacă este selectată „Luni”, o sumă fixă va fi înregistrată ca venit sau cheltuială amânată pentru fiecare lună, indiferent de numărul de zile dintr-o lună. Acesta va fi proporțional dacă veniturile sau cheltuielile amânate nu sunt înregistrate pentru o lună întreagă",
-"If this is unchecked, direct GL entries will be created to book deferred revenue or expense","Dacă acest lucru nu este bifat, vor fi create intrări GL directe pentru a înregistra venituri sau cheltuieli amânate",
-Show Inclusive Tax in Print,Afișați impozitul inclus în tipar,
-Only select this if you have set up the Cash Flow Mapper documents,Selectați acest lucru numai dacă ați configurat documentele Cartografierii fluxurilor de numerar,
-Payment Channel,Canal de plată,
-Is Purchase Order Required for Purchase Invoice & Receipt Creation?,Este necesară comanda de cumpărare pentru crearea facturii de achiziție și a chitanței?,
-Is Purchase Receipt Required for Purchase Invoice Creation?,Este necesară chitanța de cumpărare pentru crearea facturii de cumpărare?,
-Maintain Same Rate Throughout the Purchase Cycle,Mențineți aceeași rată pe tot parcursul ciclului de cumpărare,
-Allow Item To Be Added Multiple Times in a Transaction,Permiteți adăugarea articolului de mai multe ori într-o tranzacție,
-Suppliers,Furnizori,
-Send Emails to Suppliers,Trimiteți e-mailuri furnizorilor,
-Select a Supplier,Selectați un furnizor,
-Cannot mark attendance for future dates.,Nu se poate marca prezența pentru date viitoare.,
-Do you want to update attendance? <br> Present: {0} <br> Absent: {1},Doriți să actualizați prezența?<br> Prezent: {0}<br> Absent: {1},
-Mpesa Settings,Setări Mpesa,
-Initiator Name,Numele inițiatorului,
-Till Number,Până la numărul,
-Sandbox,Sandbox,
- Online PassKey,Online PassKey,
-Security Credential,Acreditare de securitate,
-Get Account Balance,Obțineți soldul contului,
-Please set the initiator name and the security credential,Vă rugăm să setați numele inițiatorului și acreditările de securitate,
-Inpatient Medication Entry,Intrarea în medicamente pentru pacienții internați,
-HLC-IME-.YYYY.-,HLC-IME-.YYYY.-,
-Item Code (Drug),Cod articol (medicament),
-Medication Orders,Comenzi de medicamente,
-Get Pending Medication Orders,Obțineți comenzi de medicamente în așteptare,
-Inpatient Medication Orders,Comenzi pentru medicamente internate,
-Medication Warehouse,Depozit de medicamente,
-Warehouse from where medication stock should be consumed,Depozit de unde ar trebui consumat stocul de medicamente,
-Fetching Pending Medication Orders,Preluarea comenzilor de medicamente în așteptare,
-Inpatient Medication Entry Detail,Detalii privind intrarea medicamentelor pentru pacienții internați,
-Medication Details,Detalii despre medicamente,
-Drug Code,Codul drogurilor,
-Drug Name,Numele medicamentului,
-Against Inpatient Medication Order,Împotriva ordinului privind medicamentul internat,
-Against Inpatient Medication Order Entry,Împotriva introducerii comenzii pentru medicamente internate,
-Inpatient Medication Order,Ordinul privind medicamentul internat,
-HLC-IMO-.YYYY.-,HLC-IMO-.YYYY.-,
-Total Orders,Total comenzi,
-Completed Orders,Comenzi finalizate,
-Add Medication Orders,Adăugați comenzi de medicamente,
-Adding Order Entries,Adăugarea intrărilor de comandă,
-{0} medication orders completed,{0} comenzi de medicamente finalizate,
-{0} medication order completed,{0} comandă de medicamente finalizată,
-Inpatient Medication Order Entry,Intrarea comenzii pentru medicamente internate,
-Is Order Completed,Comanda este finalizată,
-Employee Records to Be Created By,Înregistrările angajaților care trebuie create de,
-Employee records are created using the selected field,Înregistrările angajaților sunt create folosind câmpul selectat,
-Don't send employee birthday reminders,Nu trimiteți memento-uri de ziua angajaților,
-Restrict Backdated Leave Applications,Restricționează aplicațiile de concediu actualizate,
-Sequence ID,ID secvență,
-Sequence Id,Secvența Id,
-Allow multiple material consumptions against a Work Order,Permiteți mai multe consumuri de materiale împotriva unei comenzi de lucru,
-Plan time logs outside Workstation working hours,Planificați jurnalele de timp în afara programului de lucru al stației de lucru,
-Plan operations X days in advance,Planificați operațiunile cu X zile înainte,
-Time Between Operations (Mins),Timpul dintre operații (min.),
-Default: 10 mins,Implicit: 10 minute,
-Overproduction for Sales and Work Order,Supraproducție pentru vânzări și comandă de lucru,
-"Update BOM cost automatically via scheduler, based on the latest Valuation Rate/Price List Rate/Last Purchase Rate of raw materials","Actualizați automat costul BOM prin programator, pe baza celei mai recente rate de evaluare / tarif de listă de prețuri / ultimul procent de cumpărare a materiilor prime",
-Purchase Order already created for all Sales Order items,Comanda de cumpărare deja creată pentru toate articolele comenzii de vânzare,
-Select Items,Selectați elemente,
-Against Default Supplier,Împotriva furnizorului implicit,
-Auto close Opportunity after the no. of days mentioned above,Închidere automată Oportunitate după nr. de zile menționate mai sus,
-Is Sales Order Required for Sales Invoice & Delivery Note Creation?,Este necesară comanda de vânzare pentru crearea facturilor de vânzare și a notelor de livrare?,
-Is Delivery Note Required for Sales Invoice Creation?,Este necesară nota de livrare pentru crearea facturii de vânzare?,
-How often should Project and Company be updated based on Sales Transactions?,Cât de des ar trebui actualizate proiectul și compania pe baza tranzacțiilor de vânzare?,
-Allow User to Edit Price List Rate in Transactions,Permiteți utilizatorului să editeze rata listei de prețuri în tranzacții,
-Allow Item to Be Added Multiple Times in a Transaction,Permiteți adăugarea articolului de mai multe ori într-o tranzacție,
-Allow Multiple Sales Orders Against a Customer's Purchase Order,Permiteți mai multe comenzi de vânzare împotriva comenzii de cumpărare a unui client,
-Validate Selling Price for Item Against Purchase Rate or Valuation Rate,Validați prețul de vânzare al articolului împotriva ratei de achiziție sau a ratei de evaluare,
-Hide Customer's Tax ID from Sales Transactions,Ascundeți codul fiscal al clientului din tranzacțiile de vânzare,
-"The 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 pe care vi se permite să îl primiți sau să livrați mai mult în raport cu cantitatea comandată. De exemplu, dacă ați comandat 100 de unități, iar alocația dvs. este de 10%, atunci aveți permisiunea de a primi 110 unități.",
-Action If Quality Inspection Is Not Submitted,Acțiune dacă inspecția de calitate nu este trimisă,
-Auto Insert Price List Rate If Missing,Introduceți automat prețul listei de prețuri dacă lipsește,
-Automatically Set Serial Nos Based on FIFO,Setați automat numărul de serie pe baza FIFO,
-Set Qty in Transactions Based on Serial No Input,Setați cantitatea în tranzacțiile bazate pe intrare de serie,
-Raise Material Request When Stock Reaches Re-order Level,Creșteți cererea de material atunci când stocul atinge nivelul de re-comandă,
-Notify by Email on Creation of Automatic Material Request,Notificați prin e-mail la crearea cererii automate de materiale,
-Allow Material Transfer from Delivery Note to Sales Invoice,Permiteți transferul de materiale din nota de livrare către factura de vânzare,
-Allow Material Transfer from Purchase Receipt to Purchase Invoice,Permiteți transferul de materiale de la chitanța de cumpărare la factura de cumpărare,
-Freeze Stocks Older Than (Days),Înghețați stocurile mai vechi de (zile),
-Role Allowed to Edit Frozen Stock,Rolul permis pentru editarea stocului înghețat,
-The unallocated amount of Payment Entry {0} is greater than the Bank Transaction's unallocated amount,Valoarea nealocată a intrării de plată {0} este mai mare decât suma nealocată a tranzacției bancare,
-Payment Received,Plata primita,
-Attendance cannot be marked outside of Academic Year {0},Prezența nu poate fi marcată în afara anului academic {0},
-Student is already enrolled via Course Enrollment {0},Studentul este deja înscris prin Înscrierea la curs {0},
-Attendance cannot be marked for future dates.,Prezența nu poate fi marcată pentru datele viitoare.,
-Please add programs to enable admission application.,Vă rugăm să adăugați programe pentru a activa cererea de admitere.,
-The following employees are currently still reporting to {0}:,"În prezent, următorii angajați raportează încă la {0}:",
-Please make sure the employees above report to another Active employee.,Vă rugăm să vă asigurați că angajații de mai sus raportează unui alt angajat activ.,
-Cannot Relieve Employee,Nu poate scuti angajatul,
-Please enter {0},Vă rugăm să introduceți {0},
-Please select another payment method. Mpesa does not support transactions in currency '{0}',Vă rugăm să selectați o altă metodă de plată. Mpesa nu acceptă tranzacții în moneda „{0}”,
-Transaction Error,Eroare de tranzacție,
-Mpesa Express Transaction Error,Eroare tranzacție Mpesa Express,
-"Issue detected with Mpesa configuration, check the error logs for more details","Problemă detectată la configurația Mpesa, verificați jurnalele de erori pentru mai multe detalii",
-Mpesa Express Error,Eroare Mpesa Express,
-Account Balance Processing Error,Eroare procesare sold sold,
-Please check your configuration and try again,Vă rugăm să verificați configurația și să încercați din nou,
-Mpesa Account Balance Processing Error,Eroare de procesare a soldului contului Mpesa,
-Balance Details,Detalii sold,
-Current Balance,Sold curent,
-Available Balance,Sold disponibil,
-Reserved Balance,Sold rezervat,
-Uncleared Balance,Sold neclar,
-Payment related to {0} is not completed,Plata aferentă {0} nu este finalizată,
-Row #{}: Item Code: {} is not available under warehouse {}.,Rândul # {}: Codul articolului: {} nu este disponibil în depozit {}.,
-Row #{}: Stock quantity not enough for Item Code: {} under warehouse {}. Available quantity {}.,Rândul # {}: cantitatea de stoc nu este suficientă pentru codul articolului: {} în depozit {}. Cantitate Disponibilă {}.,
-Row #{}: Please select a serial no and batch against item: {} or remove it to complete transaction.,Rândul # {}: selectați un număr de serie și împărțiți-l cu elementul: {} sau eliminați-l pentru a finaliza tranzacția.,
-Row #{}: No serial number selected against item: {}. Please select one or remove it to complete transaction.,Rândul # {}: nu a fost selectat niciun număr de serie pentru elementul: {}. Vă rugăm să selectați una sau să o eliminați pentru a finaliza tranzacția.,
-Row #{}: No batch selected against item: {}. Please select a batch or remove it to complete transaction.,Rândul # {}: nu a fost selectat niciun lot pentru elementul: {}. Vă rugăm să selectați un lot sau să îl eliminați pentru a finaliza tranzacția.,
-Payment amount cannot be less than or equal to 0,Suma plății nu poate fi mai mică sau egală cu 0,
-Please enter the phone number first,Vă rugăm să introduceți mai întâi numărul de telefon,
-Row #{}: {} {} does not exist.,Rândul # {}: {} {} nu există.,
-Row #{0}: {1} is required to create the Opening {2} Invoices,Rândul # {0}: {1} este necesar pentru a crea facturile de deschidere {2},
-You had {} errors while creating opening invoices. Check {} for more details,Ați avut {} erori la crearea facturilor de deschidere. Verificați {} pentru mai multe detalii,
-Error Occured,A aparut o eroare,
-Opening Invoice Creation In Progress,Se deschide crearea facturii în curs,
-Creating {} out of {} {},Se creează {} din {} {},
-(Serial No: {0}) cannot be consumed as it's reserverd to fullfill Sales Order {1}.,(Nr. De serie: {0}) nu poate fi consumat deoarece este rezervat pentru a îndeplini comanda de vânzare {1}.,
-Item {0} {1},Element {0} {1},
-Last Stock Transaction for item {0} under warehouse {1} was on {2}.,Ultima tranzacție de stoc pentru articolul {0} aflat în depozit {1} a fost pe {2}.,
-Stock Transactions for Item {0} under warehouse {1} cannot be posted before this time.,Tranzacțiile de stoc pentru articolul {0} aflat în depozit {1} nu pot fi înregistrate înainte de această dată.,
-Posting future stock transactions are not allowed due to Immutable Ledger,Înregistrarea tranzacțiilor viitoare cu acțiuni nu este permisă din cauza contabilității imuabile,
-A BOM with name {0} already exists for item {1}.,O listă cu numele {0} există deja pentru articolul {1}.,
-{0}{1} Did you rename the item? Please contact Administrator / Tech support,{0} {1} Ați redenumit articolul? Vă rugăm să contactați administratorul / asistența tehnică,
-At row #{0}: the sequence id {1} cannot be less than previous row sequence id {2},La rândul # {0}: ID-ul secvenței {1} nu poate fi mai mic decât ID-ul anterior al secvenței de rând {2},
-The {0} ({1}) must be equal to {2} ({3}),{0} ({1}) trebuie să fie egal cu {2} ({3}),
-"{0}, complete the operation {1} before the operation {2}.","{0}, finalizați operația {1} înainte de operație {2}.",
-Cannot ensure delivery by Serial No as Item {0} is added with and without Ensure Delivery by Serial No.,Nu se poate asigura livrarea prin numărul de serie deoarece articolul {0} este adăugat cu și fără Asigurați livrarea prin numărul de serie,
-Item {0} has no Serial No. Only serilialized items can have delivery based on Serial No,Articolul {0} nu are nr. De serie. Numai articolele serializate pot fi livrate pe baza numărului de serie,
-No active BOM found for item {0}. Delivery by Serial No cannot be ensured,Nu s-a găsit niciun material activ pentru articolul {0}. Livrarea prin nr. De serie nu poate fi asigurată,
-No pending medication orders found for selected criteria,Nu s-au găsit comenzi de medicamente în așteptare pentru criteriile selectate,
-From Date cannot be after the current date.,From Date nu poate fi după data curentă.,
-To Date cannot be after the current date.,To Date nu poate fi după data curentă.,
-From Time cannot be after the current time.,From Time nu poate fi după ora curentă.,
-To Time cannot be after the current time.,To Time nu poate fi după ora curentă.,
-Stock Entry {0} created and ,Înregistrare stoc {0} creată și,
-Inpatient Medication Orders updated successfully,Comenzile pentru medicamente internate au fost actualizate cu succes,
-Row {0}: Cannot create Inpatient Medication Entry against cancelled Inpatient Medication Order {1},Rândul {0}: Nu se poate crea o intrare pentru medicamentul internat împotriva comenzii anulate pentru medicamentul internat {1},
-Row {0}: This Medication Order is already marked as completed,Rândul {0}: această comandă de medicamente este deja marcată ca finalizată,
-Quantity not available for {0} in warehouse {1},Cantitatea nu este disponibilă pentru {0} în depozit {1},
-Please enable Allow Negative Stock in Stock Settings or create Stock Entry to proceed.,Vă rugăm să activați Permiteți stocul negativ în setările stocului sau creați intrarea stocului pentru a continua.,
-No Inpatient Record found against patient {0},Nu s-a găsit nicio înregistrare a pacientului internat împotriva pacientului {0},
-An Inpatient Medication Order {0} against Patient Encounter {1} already exists.,Există deja un ordin de medicare internă {0} împotriva întâlnirii pacientului {1}.,
-Allow In Returns,Permiteți returnări,
-Hide Unavailable Items,Ascundeți articolele indisponibile,
-Apply Discount on Discounted Rate,Aplicați reducere la tariful redus,
-Therapy Plan Template,Șablon de plan de terapie,
-Fetching Template Details,Preluarea detaliilor șablonului,
-Linked Item Details,Detalii legate de articol,
-Therapy Types,Tipuri de terapie,
-Therapy Plan Template Detail,Detaliu șablon plan de terapie,
-Non Conformance,Non conformist,
-Process Owner,Deținătorul procesului,
-Corrective Action,Acțiune corectivă,
-Preventive Action,Actiune preventiva,
-Problem,Problemă,
-Responsible,Responsabil,
-Completion By,Finalizare de,
-Process Owner Full Name,Numele complet al proprietarului procesului,
-Right Index,Index corect,
-Left Index,Index stânga,
-Sub Procedure,Sub procedură,
-Passed,A trecut,
-Print Receipt,Tipărire chitanță,
-Edit Receipt,Editați chitanța,
-Focus on search input,Concentrați-vă pe introducerea căutării,
-Focus on Item Group filter,Concentrați-vă pe filtrul Grup de articole,
-Checkout Order / Submit Order / New Order,Comanda de comandă / Trimiteți comanda / Comanda nouă,
-Add Order Discount,Adăugați reducere la comandă,
-Item Code: {0} is not available under warehouse {1}.,Cod articol: {0} nu este disponibil în depozit {1}.,
-Serial numbers unavailable for Item {0} under warehouse {1}. Please try changing warehouse.,Numerele de serie nu sunt disponibile pentru articolul {0} aflat în depozit {1}. Vă rugăm să încercați să schimbați depozitul.,
-Fetched only {0} available serial numbers.,S-au preluat numai {0} numere de serie disponibile.,
-Switch Between Payment Modes,Comutați între modurile de plată,
-Enter {0} amount.,Introduceți suma {0}.,
-You don't have enough points to redeem.,Nu aveți suficiente puncte de valorificat.,
-You can redeem upto {0}.,Puteți valorifica până la {0}.,
-Enter amount to be redeemed.,Introduceți suma de răscumpărat.,
-You cannot redeem more than {0}.,Nu puteți valorifica mai mult de {0}.,
-Open Form View,Deschideți vizualizarea formularului,
-POS invoice {0} created succesfully,Factura POS {0} a fost creată cu succes,
-Stock quantity not enough for Item Code: {0} under warehouse {1}. Available quantity {2}.,Cantitatea de stoc nu este suficientă pentru Codul articolului: {0} în depozit {1}. Cantitatea disponibilă {2}.,
-Serial No: {0} has already been transacted into another POS Invoice.,Nr. De serie: {0} a fost deja tranzacționat într-o altă factură POS.,
-Balance Serial No,Nr,
-Warehouse: {0} does not belong to {1},Depozit: {0} nu aparține {1},
-Please select batches for batched item {0},Vă rugăm să selectați loturile pentru elementul lot {0},
-Please select quantity on row {0},Vă rugăm să selectați cantitatea de pe rândul {0},
-Please enter serial numbers for serialized item {0},Introduceți numerele de serie pentru articolul serializat {0},
-Batch {0} already selected.,Lotul {0} deja selectat.,
-Please select a warehouse to get available quantities,Vă rugăm să selectați un depozit pentru a obține cantitățile disponibile,
-"For transfer from source, selected quantity cannot be greater than available quantity","Pentru transfer din sursă, cantitatea selectată nu poate fi mai mare decât cantitatea disponibilă",
-Cannot find Item with this Barcode,Nu se poate găsi un articol cu acest cod de bare,
-{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2},{0} este obligatoriu. Poate că înregistrarea schimbului valutar nu este creată pentru {1} până la {2},
-{} has submitted assets linked to it. You need to cancel the assets to create purchase return.,{} a trimis materiale legate de acesta. Trebuie să anulați activele pentru a crea returnarea achiziției.,
-Cannot cancel this document as it is linked with submitted asset {0}. Please cancel it to continue.,Nu se poate anula acest document deoarece este asociat cu materialul trimis {0}. Anulați-l pentru a continua.,
-Row #{}: Serial No. {} has already been transacted into another POS Invoice. Please select valid serial no.,Rândul # {}: numărul de serie {} a fost deja tranzacționat într-o altă factură POS. Vă rugăm să selectați numărul de serie valid.,
-Row #{}: Serial Nos. {} has already been transacted into another POS Invoice. Please select valid serial no.,Rândul # {}: Nr. De serie {} a fost deja tranzacționat într-o altă factură POS. Vă rugăm să selectați numărul de serie valid.,
-Item Unavailable,Elementul nu este disponibil,
-Row #{}: Serial No {} cannot be returned since it was not transacted in original invoice {},Rândul # {}: seria nr. {} Nu poate fi returnată deoarece nu a fost tranzacționată în factura originală {},
-Please set default Cash or Bank account in Mode of Payment {},Vă rugăm să setați implicit numerar sau cont bancar în modul de plată {},
-Please set default Cash or Bank account in Mode of Payments {},Vă rugăm să setați implicit numerar sau cont bancar în modul de plăți {},
-Please ensure {} account is a Balance Sheet account. You can change the parent account to a Balance Sheet account or select a different account.,Vă rugăm să vă asigurați că {} contul este un cont de bilanț. Puteți schimba contul părinte într-un cont de bilanț sau puteți selecta un alt cont.,
-Please ensure {} account is a Payable account. Change the account type to Payable or select a different account.,Vă rugăm să vă asigurați că {} contul este un cont de plătit. Schimbați tipul de cont la Plătibil sau selectați un alt cont.,
-Row {}: Expense Head changed to {} ,Rând {}: capul cheltuielilor a fost schimbat în {},
-because account {} is not linked to warehouse {} ,deoarece contul {} nu este conectat la depozit {},
-or it is not the default inventory account,sau nu este contul de inventar implicit,
-Expense Head Changed,Capul cheltuielilor s-a schimbat,
-because expense is booked against this account in Purchase Receipt {},deoarece cheltuielile sunt rezervate pentru acest cont în chitanța de cumpărare {},
-as no Purchase Receipt is created against Item {}. ,deoarece nu se creează chitanță de cumpărare împotriva articolului {}.,
-This is done to handle accounting for cases when Purchase Receipt is created after Purchase Invoice,Acest lucru se face pentru a gestiona contabilitatea cazurilor în care Bonul de cumpărare este creat după factura de achiziție,
-Purchase Order Required for item {},Comandă de achiziție necesară pentru articolul {},
-To submit the invoice without purchase order please set {} ,"Pentru a trimite factura fără comandă de cumpărare, setați {}",
-as {} in {},ca în {},
-Mandatory Purchase Order,Comandă de cumpărare obligatorie,
-Purchase Receipt Required for item {},Chitanță de cumpărare necesară pentru articolul {},
-To submit the invoice without purchase receipt please set {} ,"Pentru a trimite factura fără chitanță de cumpărare, setați {}",
-Mandatory Purchase Receipt,Chitanță de cumpărare obligatorie,
-POS Profile {} does not belongs to company {},Profilul POS {} nu aparține companiei {},
-User {} is disabled. Please select valid user/cashier,Utilizatorul {} este dezactivat. Vă rugăm să selectați un utilizator / casier valid,
-Row #{}: Original Invoice {} of return invoice {} is {}. ,Rândul # {}: factura originală {} a facturii de returnare {} este {}.,
-Original invoice should be consolidated before or along with the return invoice.,Factura originală ar trebui consolidată înainte sau împreună cu factura de returnare.,
-You can add original invoice {} manually to proceed.,Puteți adăuga factura originală {} manual pentru a continua.,
-Please ensure {} account is a Balance Sheet account. ,Vă rugăm să vă asigurați că {} contul este un cont de bilanț.,
-You can change the parent account to a Balance Sheet account or select a different account.,Puteți schimba contul părinte într-un cont de bilanț sau puteți selecta un alt cont.,
-Please ensure {} account is a Receivable account. ,Vă rugăm să vă asigurați că {} contul este un cont de încasat.,
-Change the account type to Receivable or select a different account.,Schimbați tipul de cont pentru de primit sau selectați un alt cont.,
-{} can't be cancelled since the Loyalty Points earned has been redeemed. First cancel the {} No {},"{} nu poate fi anulat, deoarece punctele de loialitate câștigate au fost valorificate. Anulați mai întâi {} Nu {}",
-already exists,deja exista,
-POS Closing Entry {} against {} between selected period,Închidere POS {} contra {} între perioada selectată,
-POS Invoice is {},Factura POS este {},
-POS Profile doesn't matches {},Profilul POS nu se potrivește cu {},
-POS Invoice is not {},Factura POS nu este {},
-POS Invoice isn't created by user {},Factura POS nu este creată de utilizator {},
-Row #{}: {},Rând #{}: {},
-Invalid POS Invoices,Facturi POS nevalide,
-Please add the account to root level Company - {},Vă rugăm să adăugați contul la compania la nivel de rădăcină - {},
-"While creating account for Child Company {0}, parent account {1} not found. Please create the parent account in corresponding COA","În timp ce creați un cont pentru Compania copil {0}, contul părinte {1} nu a fost găsit. Vă rugăm să creați contul părinte în COA corespunzător",
-Account Not Found,Contul nu a fost găsit,
-"While creating account for Child Company {0}, parent account {1} found as a ledger account.","În timp ce creați un cont pentru Compania pentru copii {0}, contul părinte {1} a fost găsit ca un cont mare.",
-Please convert the parent account in corresponding child company to a group account.,Vă rugăm să convertiți contul părinte al companiei copil corespunzătoare într-un cont de grup.,
-Invalid Parent Account,Cont părinte nevalid,
-"Renaming it is only allowed via parent company {0}, to avoid mismatch.","Redenumirea acestuia este permisă numai prin intermediul companiei-mamă {0}, pentru a evita nepotrivirea.",
-"If you {0} {1} quantities of the item {2}, the scheme {3} will be applied on the item.","Dacă {0} {1} cantitățile articolului {2}, schema {3} va fi aplicată articolului.",
-"If you {0} {1} worth item {2}, the scheme {3} will be applied on the item.","Dacă {0} {1} valorează articolul {2}, schema {3} va fi aplicată articolului.",
-"As the field {0} is enabled, the field {1} is mandatory.","Deoarece câmpul {0} este activat, câmpul {1} este obligatoriu.",
-"As the field {0} is enabled, the value of the field {1} should be more than 1.","Deoarece câmpul {0} este activat, valoarea câmpului {1} trebuie să fie mai mare de 1.",
-Cannot deliver Serial No {0} of item {1} as it is reserved to fullfill Sales Order {2},Nu se poate livra numărul de serie {0} al articolului {1} deoarece este rezervat pentru a îndeplini comanda de vânzare {2},
-"Sales Order {0} has reservation for the item {1}, you can only deliver reserved {1} against {0}.","Comanda de vânzări {0} are rezervare pentru articolul {1}, puteți livra rezervat {1} numai cu {0}.",
-{0} Serial No {1} cannot be delivered,{0} Numărul de serie {1} nu poate fi livrat,
-Row {0}: Subcontracted Item is mandatory for the raw material {1},Rândul {0}: articolul subcontractat este obligatoriu pentru materia primă {1},
-"As there are sufficient raw materials, Material Request is not required for Warehouse {0}.","Deoarece există suficiente materii prime, cererea de material nu este necesară pentru depozit {0}.",
-" If you still want to proceed, please enable {0}.","Dacă totuși doriți să continuați, activați {0}.",
-The item referenced by {0} - {1} is already invoiced,Elementul la care face referire {0} - {1} este deja facturat,
-Therapy Session overlaps with {0},Sesiunea de terapie se suprapune cu {0},
-Therapy Sessions Overlapping,Sesiunile de terapie se suprapun,
-Therapy Plans,Planuri de terapie,
-"Item Code, warehouse, quantity are required on row {0}","Codul articolului, depozitul, cantitatea sunt necesare pe rândul {0}",
-Get Items from Material Requests against this Supplier,Obțineți articole din solicitările materiale împotriva acestui furnizor,
-Enable European Access,Activați accesul european,
-Creating Purchase Order ...,Se creează comanda de cumpărare ...,
-"Select a Supplier from the Default Suppliers of the items below. On selection, a Purchase Order will be made against items belonging to the selected Supplier only.","Selectați un furnizor din furnizorii prestabiliți ai articolelor de mai jos. La selectare, o comandă de achiziție va fi făcută numai pentru articolele aparținând furnizorului selectat.",
-Row #{}: You must select {} serial numbers for item {}.,Rândul # {}: trebuie să selectați {} numere de serie pentru articol {}.,
+"""Customer Provided Item"" cannot be Purchase Item also","""Elementul furnizat de client"" nu poate fi și articolul de cumpărare",
+"""Customer Provided Item"" cannot have Valuation Rate","""Elementul furnizat de client"" nu poate avea rata de evaluare",
+"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","""Este activ fix"" nu poate fi debifată deoarece există informații împotriva produsului",
+'Based On' and 'Group By' can not be same,'Bazat pe' și 'Grupat dupa' nu pot fi identice,
+'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 pot fi vide,
+'From Date' is required,'Din Data' este necesar,
+'From Date' must be after 'To Date','Din Data' trebuie să fie dupã 'Până în Data',
+'Has Serial No' can not be 'Yes' for non-stock item,'Are numãr de serie' nu poate fi 'Da' pentru articolele care nu au stoc,
+'Opening',&quot;Deschiderea&quot;,
+'To Case No.' cannot be less than 'From Case No.','Până la situația nr.' nu poate fi mai mică decât 'De la situația nr.',
+'To Date' is required,'Până la data' este necesară,
+'Total',&#39;Total&#39;,
+'Update Stock' can not be checked because items are not delivered via {0},"""Actualizare stoc"" nu poate fi activat, deoarece obiectele nu sunt livrate prin {0}",
+'Update Stock' cannot be checked for fixed asset sale,&quot;Actualizare stoc&quot; nu poate fi verificată de vânzare de active fixe,
+) for {0},) pentru {0},
+1 exact match.,1 potrivire exactă.,
+90-Above,90-si mai mult,
+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 să redenumiți grupul de clienți,
+A Default Service Level Agreement already exists.,Există deja un Acord de nivel de serviciu implicit.,
+A Lead requires either a person's name or an organization's name,"Un conducător necesită fie numele unei persoane, fie numele unei organizații",
+A customer with the same name already exists,Un client cu același nume există deja,
+A question must have more than one options,O întrebare trebuie să aibă mai multe opțiuni,
+A qustion must have at least one correct options,O chestiune trebuie să aibă cel puțin o opțiune corectă,
+A {0} exists between {1} and {2} (,A {0} există între {1} și {2} (,
+A4,A4,
+API Endpoint,API Endpoint,
+API Key,Cheie API,
+Abbr can not be blank or space,Abr. nu poate fi gol sau spațiu,
+Abbreviation already used for another company,Abreviere deja folosita pentru o altă companie,
+Abbreviation cannot have more than 5 characters,Prescurtarea nu poate conține mai mult de 5 caractere,
+Abbreviation is mandatory,Abreviere este obligatorie,
+About the Company,Despre companie,
+About your company,Despre Compania ta,
+Above,Deasupra,
+Absent,Absent,
+Academic Term,Termen academic,
+Academic Term: ,Termen academic:,
+Academic Year,An academic,
+Academic Year: ,An academic:,
+Accepted + Rejected Qty must be equal to Received quantity for Item {0},Cant. acceptată + respinsă trebuie să fie egală cu cantitatea recepționată pentru articolul {0},
+Access Token,Acces Token,
+Accessable Value,Valoare accesibilă,
+Account,Cont,
+Account Number,Numar de cont,
+Account Number {0} already used in account {1},Numărul contului {0} deja utilizat în contul {1},
+Account Pay Only,Contul Plătiți numai,
+Account Type,Tipul Contului,
+Account Type for {0} must be {1},Tipul de cont pentru {0} trebuie să fie {1},
+"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Soldul contului este deja în credit, nu vă este permis să setați ""Balanța trebuie să fie"" drept ""Debit"".",
+"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Soldul contului este deja în credit, nu vă este permis să setați ""Balanța trebuie să fie"" drept ""Credit"".",
+Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Numărul contului pentru contul {0} nu este disponibil. <br> Vă rugăm să configurați corect planul de conturi.,
+Account with child nodes cannot be converted to ledger,Un cont cu noduri copil nu poate fi transformat în registru contabil,
+Account with child nodes cannot be set as ledger,Cont cu noduri copil nu poate fi setat ca Registru Contabil,
+Account with existing transaction can not be converted to group.,Un cont cu tranzacții existente nu poate fi transformat în grup.,
+Account with existing transaction can not be deleted,Un cont cu tranzacții existente nu poate fi șters,
+Account with existing transaction cannot be converted to ledger,Un cont cu tranzacții existente nu poate fi transformat în registru contabil,
+Account {0} does not belong to company: {1},Contul {0} nu aparține companiei: {1},
+Account {0} does not belongs to company {1},Contul {0} nu aparține companiei {1},
+Account {0} does not exist,Contul {0} nu există,
+Account {0} does not exists,Contul {0} nu există,
+Account {0} does not match with Company {1} in Mode of Account: {2},Contul {0} nu se potrivește cu Compania {1} în modul de cont: {2},
+Account {0} has been entered multiple times,Contul {0} a fost introdus de mai multe ori,
+Account {0} is added in the child company {1},Contul {0} este adăugat în compania copil {1},
+Account {0} is frozen,Contul {0} este Blocat,
+Account {0} is invalid. Account Currency must be {1},Contul {0} nu este valid. Valuta contului trebuie să fie {1},
+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 există,
+Account {0}: You can not assign itself as parent account,Contul {0}: nu puteți atribui contului în sine calitatea de cont părinte,
+Account: {0} can only be updated via Stock Transactions,Contul: {0} poate fi actualizat doar prin Tranzacții stoc,
+Account: {0} with currency: {1} can not be selected,Contul: {0} cu moneda: {1} nu poate fi selectat,
+Accountant,Contabil,
+Accounting,Contabilitate,
+Accounting Entry for Asset,Înregistrare contabilă a activelor,
+Accounting Entry for Stock,Intrare Contabilă pentru Stoc,
+Accounting Entry for {0}: {1} can only be made in currency: {2},Intrarea contabila pentru {0}: {1} se poate face numai în valuta: {2},
+Accounting Ledger,Registru Jurnal,
+Accounting journal entries.,Inregistrari contabile de jurnal.,
+Accounts,Conturi,
+Accounts Manager,Manager de Conturi,
+Accounts Payable,Conturi de plată,
+Accounts Payable Summary,Rezumat conturi pentru plăți,
+Accounts Receivable,Conturi de Incasare,
+Accounts Receivable Summary,Rezumat conturi de încasare,
+Accounts User,Conturi de utilizator,
+Accounts table cannot be blank.,Planul de conturi nu poate fi gol.,
+Accrual Journal Entry for salaries from {0} to {1},Înregistrarea jurnalelor de angajare pentru salariile de la {0} la {1},
+Accumulated Depreciation,Amortizarea cumulată,
+Accumulated Depreciation Amount,Sumă Amortizarea cumulată,
+Accumulated Depreciation as on,Amortizarea ca pe acumulat,
+Accumulated Monthly,lunar acumulat,
+Accumulated Values,Valorile acumulate,
+Accumulated Values in Group Company,Valori acumulate în compania grupului,
+Achieved ({}),Realizat ({}),
+Action,Acțiune:,
+Action Initialised,Acțiune inițiată,
+Actions,Acțiuni,
+Active,Activ,
+Activity Cost exists for Employee {0} against Activity Type - {1},Există cost activitate pentru angajatul {0} comparativ tipului de activitate - {1},
+Activity Cost per Employee,Cost activitate per angajat,
+Activity Type,Tip Activitate,
+Actual Cost,Costul actual,
+Actual Delivery Date,Data de livrare efectivă,
+Actual Qty,Cant. Efectivă,
+Actual Qty is mandatory,Cantitatea efectivă este obligatorie,
+Actual Qty {0} / Waiting Qty {1},Cant. reală {0} / Cant. în așteptare {1},
+Actual Qty: Quantity available in the warehouse.,Cantitate Actuală: Cantitate disponibilă în depozit.,
+Actual qty in stock,Cant. efectivă în stoc,
+Actual type tax cannot be included in Item rate in row {0},Taxa efectivă de tip nu poate fi inclusă în tariful articolului din rândul {0},
+Add,Adaugă,
+Add / Edit Prices,Adăugați / editați preturi,
+Add Comment,Adăugă Comentariu,
+Add Customers,Adăugați clienți,
+Add Employees,Adăugă Angajați,
+Add Item,Adăugă Element,
+Add Items,Adăugă Elemente,
+Add Leads,Adaugă Oportunități,
+Add Multiple Tasks,Adăugă Sarcini Multiple,
+Add Row,Adăugă Rând,
+Add Sales Partners,Adăugă Parteneri de Vânzări,
+Add Serial No,Adăugaţi Nr. de Serie,
+Add Students,Adăugă Elevi,
+Add Suppliers,Adăugă Furnizori,
+Add Time Slots,Adăugă Intervale de Timp,
+Add Timesheets,Adăugă Pontaje,
+Add Timeslots,Adăugă Intervale de Timp,
+Add Users to Marketplace,Adăugă Utilizatori la Marketplace,
+Add a new address,Adăugați o adresă nouă,
+Add cards or custom sections on homepage,Adăugați carduri sau secțiuni personalizate pe pagina principală,
+Add more items or open full form,Adăugă mai multe elemente sau deschide formular complet,
+Add notes,Adăugați note,
+Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,"Adăugați restul organizației dvs. ca utilizatori. Puteți, de asemenea, invita Clienții în portal prin adăugarea acestora din Contacte",
+Add to Details,Adăugă la Detalii,
+Add/Remove Recipients,Adăugaţi/Stergeţi Destinatari,
+Added,Adăugat,
+Added to details,Adăugat la detalii,
+Added {0} users,{0} utilizatori adăugați,
+Additional Salary Component Exists.,Există o componentă suplimentară a salariului.,
+Address,Adresă,
+Address Line 2,Adresă Linie 2,
+Address Name,Numele adresei,
+Address Title,Titlu adresă,
+Address Type,Tip adresă,
+Administrative Expenses,Cheltuieli administrative,
+Administrative Officer,Ofițer administrativ,
+Administrator,Administrator,
+Admission,Admitere,
+Admission and Enrollment,Admitere și înscriere,
+Admissions for {0},Admitere pentru {0},
+Admit,admite,
+Admitted,Admis,
+Advance Amount,Sumă în avans,
+Advance Payments,Plățile în avans,
+Advance account currency should be same as company currency {0},Advance valuta contului ar trebui să fie aceeași ca moneda companiei {0},
+Advance amount cannot be greater than {0} {1},Suma avans nu poate fi mai mare decât {0} {1},
+Advertising,Publicitate,
+Aerospace,Spaţiul aerian,
+Against,Comparativ,
+Against Account,Comparativ contului,
+Against Journal Entry {0} does not have any unmatched {1} entry,Comparativ intrării {0} în jurnal nu are nici o intrare nepotrivită {1},
+Against Journal Entry {0} is already adjusted against some other voucher,Comparativ intrării {0} în jurnal este deja ajustată comparativ altui voucher,
+Against Supplier Invoice {0} dated {1},Contra facturii furnizorului {0} din data {1},
+Against Voucher,Contra voucherului,
+Against Voucher Type,Contra tipului de voucher,
+Age,Vârstă,
+Age (Days),Vârsta (zile),
+Ageing Based On,Uzură bazată pe,
+Ageing Range 1,Clasă de uzură 1,
+Ageing Range 2,Clasă de uzură 2,
+Ageing Range 3,Clasă de uzură 3,
+Agriculture,Agricultură,
+Agriculture (beta),Agricultura (beta),
+Airline,linie aeriană,
+All Accounts,Toate conturile,
+All Addresses.,Toate adresele.,
+All Assessment Groups,Toate grupurile de evaluare,
+All BOMs,toate BOM,
+All Contacts.,Toate contactele.,
+All Customer Groups,Toate grupurile de clienți,
+All Day,Toată ziua,
+All Departments,Toate departamentele,
+All Healthcare Service Units,Toate unitățile de servicii medicale,
+All Item Groups,Toate grupurile articolului,
+All Jobs,Toate locurile de muncă,
+All Products,Toate produsele,
+All Products or Services.,Toate produsele sau serviciile.,
+All Student Admissions,Toate Admitere Student,
+All Supplier Groups,Toate grupurile de furnizori,
+All Supplier scorecards.,Toate cardurile de evaluare ale furnizorilor.,
+All Territories,Toate Teritoriile,
+All Warehouses,toate Depozite,
+All communications including and above this shall be moved into the new Issue,"Toate comunicările, inclusiv și deasupra acestora, vor fi mutate în noua ediție",
+All items have already been transferred for this Work Order.,Toate articolele au fost deja transferate pentru această comandă de lucru.,
+All other ITC,Toate celelalte ITC,
+All the mandatory Task for employee creation hasn't been done yet.,Toate sarcinile obligatorii pentru crearea de angajați nu au fost încă încheiate.,
+Allocate Payment Amount,Alocați suma de plată,
+Allocated Amount,Sumă alocată,
+Allocated Leaves,Frunzele alocate,
+Allocating leaves...,Alocarea frunzelor ...,
+Already record exists for the item {0},Încă există înregistrare pentru articolul {0},
+"Already set default in pos profile {0} for user {1}, kindly disabled default","Deja a fost setat implicit în profilul pos {0} pentru utilizatorul {1}, dezactivat în mod prestabilit",
+Alternate Item,Articol alternativ,
+Alternative item must not be same as item code,Elementul alternativ nu trebuie să fie identic cu cel al articolului,
+Amended From,Modificat din,
+Amount,Sumă,
+Amount After Depreciation,Suma după amortizare,
+Amount of Integrated Tax,Suma impozitului integrat,
+Amount of TDS Deducted,Cantitatea de TDS dedusă,
+Amount should not be less than zero.,Suma nu trebuie să fie mai mică de zero.,
+Amount to Bill,Sumă pentru facturare,
+Amount {0} {1} against {2} {3},Suma {0} {1} împotriva {2} {3},
+Amount {0} {1} deducted against {2},Suma {0} {1} dedusă împotriva {2},
+Amount {0} {1} transferred from {2} to {3},Suma {0} {1} transferată de la {2} la {3},
+Amount {0} {1} {2} {3},Suma {0} {1} {2} {3},
+Amt,Suma,
+"An Item Group exists with same name, please change the item name or rename the item group","Există un grup de articole cu aceeaşi denumire, vă rugăm să schimbați denumirea articolului sau să redenumiţi grupul articolului",
+An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Un termen academic cu acest &quot;An universitar&quot; {0} și &quot;Numele Termenul&quot; {1} există deja. Vă rugăm să modificați aceste intrări și încercați din nou.,
+An error occurred during the update process,A apărut o eroare în timpul procesului de actualizare,
+"An item exists with same name ({0}), please change the item group name or rename the item","Există un articol cu aceeaşi denumire ({0}), vă rugăm să schimbați denumirea grupului articolului sau să redenumiţi articolul",
+Analyst,Analist,
+Analytics,Google Analytics,
+Annual Billing: {0},Facturare anuală: {0},
+Annual Salary,Salariu anual,
+Anonymous,Anonim,
+Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},O altă înregistrare bugetară {0} există deja pentru {1} &#39;{2}&#39; și contul &#39;{3}&#39; pentru anul fiscal {4},
+Another Period Closing Entry {0} has been made after {1},O altă intrare închidere de perioada {0} a fost efectuată după {1},
+Another Sales Person {0} exists with the same Employee id,Un alt Sales Person {0} există cu același ID Angajat,
+Antibiotic,Antibiotic,
+Apparel & Accessories,Îmbrăcăminte și accesorii,
+Applicable For,Aplicabil pentru,
+"Applicable if the company is SpA, SApA or SRL","Se aplică dacă compania este SpA, SApA sau SRL",
+Applicable if the company is a limited liability company,Se aplică dacă compania este o societate cu răspundere limitată,
+Applicable if the company is an Individual or a Proprietorship,Se aplică dacă compania este o persoană fizică sau o proprietate,
+Applicant,Solicitant,
+Applicant Type,Tipul solicitantului,
+Application of Funds (Assets),Aplicarea fondurilor (active),
+Application period cannot be across two allocation records,Perioada de aplicare nu poate fi cuprinsă între două înregistrări de alocare,
+Application period cannot be outside leave allocation period,Perioada de aplicare nu poate fi perioadă de alocare concediu în afara,
+Applied,Aplicat,
+Apply Now,Aplica acum,
+Appointment Confirmation,Confirmare programare,
+Appointment Duration (mins),Durata intalnire (minute),
+Appointment Type,Tip de întâlnire,
+Appointment {0} and Sales Invoice {1} cancelled,Mențiunea {0} și factura de vânzări {1} au fost anulate,
+Appointments and Encounters,Numiri și întâlniri,
+Appointments and Patient Encounters,Numiri și întâlniri cu pacienții,
+Appraisal {0} created for Employee {1} in the given date range,Expertiza {0} creată pentru angajatul {1} în intervalul de timp dat,
+Apprentice,Începător,
+Approval Status,Status aprobare,
+Approval Status must be 'Approved' or 'Rejected',"Statusul aprobării trebuie să fie ""Aprobat"" sau ""Respins""",
+Approve,Aproba,
+Approving Role cannot be same as role the rule is Applicable To,Aprobarea unui rol nu poate fi aceeaşi cu rolul. Regula este aplicabilă pentru,
+Approving User cannot be same as user the rule is Applicable To,Aprobarea unui utilizator nu poate fi aceeași cu utilizatorul. Regula este aplicabilă pentru,
+"Apps using current key won't be able to access, are you sure?","Aplicațiile care utilizează cheia curentă nu vor putea accesa, sunteți sigur?",
+Are you sure you want to cancel this appointment?,Sigur doriți să anulați această întâlnire?,
+Arrear,restanță,
+As Examiner,Ca Examiner,
+As On Date,Ca pe data,
+As Supervisor,Ca supraveghetor,
+As per rules 42 & 43 of CGST Rules,Conform regulilor 42 și 43 din Regulile CGST,
+As per section 17(5),În conformitate cu secțiunea 17 (5),
+As per your assigned Salary Structure you cannot apply for benefits,"În conformitate cu structura salarială atribuită, nu puteți aplica pentru beneficii",
+Assessment,Evaluare,
+Assessment Criteria,Criterii de evaluare,
+Assessment Group,Grup de evaluare,
+Assessment Group: ,Grup de evaluare:,
+Assessment Plan,Plan de evaluare,
+Assessment Plan Name,Numele planului de evaluare,
+Assessment Report,Raport de evaluare,
+Assessment Reports,Rapoarte de evaluare,
+Assessment Result,Rezultatul evaluării,
+Assessment Result record {0} already exists.,Inregistrarea Rezultatului evaluării {0} există deja.,
+Asset,activ,
+Asset Category,Categorie activ,
+Asset Category is mandatory for Fixed Asset item,Categorie Activ este obligatorie pentru articolul Activ Fix,
+Asset Maintenance,Întreținerea activelor,
+Asset Movement,Miscarea activelor,
+Asset Movement record {0} created,Mișcarea de înregistrare a activelor {0} creat,
+Asset Name,Denumire activ,
+Asset Received But Not Billed,"Activul primit, dar nu facturat",
+Asset Value Adjustment,Ajustarea valorii activelor,
+"Asset cannot be cancelled, as it is already {0}","Activul nu poate fi anulat, deoarece este deja {0}",
+Asset scrapped via Journal Entry {0},Activ casate prin Jurnal de intrare {0},
+"Asset {0} cannot be scrapped, as it is already {1}","Activul {0} nu poate fi scos din uz, deoarece este deja {1}",
+Asset {0} does not belong to company {1},Activul {0} nu aparține companiei {1},
+Asset {0} must be submitted,Activul {0} trebuie transmis,
+Assets,Active,
+Assign,Atribuiţi,
+Assign Salary Structure,Alocați structurii salariale,
+Assign To,Atribuţi pentru,
+Assign to Employees,Atribuie la Angajați,
+Assigning Structures...,Alocarea structurilor ...,
+Associate,Asociaţi,
+At least one mode of payment is required for POS invoice.,Cel puțin un mod de plată este necesar factura POS.,
+Atleast one item should be entered with negative quantity in return document,Cel puțin un articol ar trebui să fie introdus cu cantitate negativa în documentul de returnare,
+Atleast one of the Selling or Buying must be selected,Cel puţin una din opţiunile de vânzare sau cumpărare trebuie să fie selectată,
+Atleast one warehouse is mandatory,Cel puţin un depozit este obligatoriu,
+Attach Logo,Atașați logo,
+Attachment,Atașament,
+Attachments,Ataşamente,
+Attendance,prezență,
+Attendance From Date and Attendance To Date is mandatory,Prezenţa de la data și Prezența până la data sunt obligatorii,
+Attendance can not be marked for future dates,Prezenţa nu poate fi consemnată pentru date viitoare,
+Attendance date can not be less than employee's joining date,Data de prezență nu poate fi anteriara datii angajarii salariatului,
+Attendance for employee {0} is already marked,Prezenţa pentru angajatul {0} este deja consemnată,
+Attendance for employee {0} is already marked for this day,Prezența pentru angajatul {0} este deja marcată pentru această zi,
+Attendance has been marked successfully.,Prezența a fost marcată cu succes.,
+Attendance not submitted for {0} as it is a Holiday.,Participarea nu a fost trimisă pentru {0} deoarece este o sărbătoare.,
+Attendance not submitted for {0} as {1} on leave.,Participarea nu a fost trimisă pentru {0} ca {1} în concediu.,
+Attribute table is mandatory,Tabelul atribut este obligatoriu,
+Attribute {0} selected multiple times in Attributes Table,Atributul {0} este selectat de mai multe ori în tabelul Atribute,
+Author,Autor,
+Authorized Signatory,Semnatar autorizat,
+Auto Material Requests Generated,Cereri materiale Auto Generat,
+Auto Repeat,Auto Repetare,
+Auto repeat document updated,Documentul repetat automat a fost actualizat,
+Automotive,Autopropulsat,
+Available,Disponibil,
+Available Leaves,Frunzele disponibile,
+Available Qty,Cantitate disponibilă,
+Available Selling,Vânzări disponibile,
+Available for use date is required,Data de utilizare disponibilă pentru utilizare este necesară,
+Available slots,Sloturi disponibile,
+Available {0},Disponibile {0},
+Available-for-use Date should be after purchase date,Data disponibilă pentru utilizare ar trebui să fie după data achiziției,
+Average Age,Varsta medie,
+Average Rate,Rata medie,
+Avg Daily Outgoing,Ieșire zilnică medie,
+Avg. Buying Price List Rate,Med. Achiziționarea ratei listei de prețuri,
+Avg. Selling Price List Rate,Med. Rata de listare a prețurilor de vânzare,
+Avg. Selling Rate,Rată Medie de Vânzare,
+BOM,BOM,
+BOM Browser,BOM Browser,
+BOM No,Nr. BOM,
+BOM Rate,Rata BOM,
+BOM Stock Report,BOM Raport stoc,
+BOM and Manufacturing Quantity are required,BOM și cantitatea de producție sunt necesare,
+BOM does not contain any stock item,BOM nu conține nici un element de stoc,
+BOM {0} does not belong to Item {1},BOM {0} nu aparţine articolului {1},
+BOM {0} must be active,BOM {0} trebuie să fie activ,
+BOM {0} must be submitted,BOM {0} trebuie să fie introdus,
+Balance,Bilanţ,
+Balance (Dr - Cr),Sold (Dr-Cr),
+Balance ({0}),Sold ({0}),
+Balance Qty,Cantitate de bilanţ,
+Balance Sheet,Bilanț,
+Balance Value,Valoarea bilanţului,
+Balance for Account {0} must always be {1},Bilanţă pentru contul {0} trebuie să fie întotdeauna {1},
+Bank,bancă,
+Bank Account,Cont bancar,
+Bank Accounts,Conturi bancare,
+Bank Draft,Ciorna bancară,
+Bank Entries,Intrările bancare,
+Bank Name,Denumire bancă,
+Bank Overdraft Account,Descoperire cont bancar,
+Bank Reconciliation,Reconciliere bancară,
+Bank Reconciliation Statement,Extras de cont reconciliere bancară,
+Bank Statement,Extras de cont,
+Bank Statement Settings,Setările declarației bancare,
+Bank Statement balance as per General Ledger,Banca echilibru Declarație pe General Ledger,
+Bank account cannot be named as {0},Contul bancar nu poate fi numit ca {0},
+Bank/Cash transactions against party or for internal transfer,tranzacții bancare / numerar contra partidului sau pentru transfer intern,
+Banking,Bancar,
+Banking and Payments,Bancare și plăți,
+Barcode {0} already used in Item {1},Cod de bare {0} deja folosit pentru articolul {1},
+Barcode {0} is not a valid {1} code,Codul de bare {0} nu este un cod valid {1},
+Base,Baza,
+Base URL,URL-ul de bază,
+Based On,Bazat pe,
+Based On Payment Terms,Pe baza condițiilor de plată,
+Basic,Elementar,
+Batch,Lot,
+Batch Entries,Înregistrări pe lot,
+Batch ID is mandatory,ID-ul lotului este obligatoriu,
+Batch Inventory,Lot Inventarul,
+Batch Name,Nume lot,
+Batch No,Lot nr.,
+Batch number is mandatory for Item {0},Numărul aferent lotului este obligatoriu pentru articolul {0},
+Batch {0} of Item {1} has expired.,Lot {0} din {1} Postul a expirat.,
+Batch {0} of Item {1} is disabled.,Lotul {0} al elementului {1} este dezactivat.,
+Batch: ,Lot:,
+Batches,Sarjele,
+Become a Seller,Deveniți un vânzător,
+Beginner,Începător,
+Bill,Factură,
+Bill Date,Dată factură,
+Bill No,Factură nr.,
+Bill of Materials,Reţete de Producţie,
+Bill of Materials (BOM),Lista de materiale (BOM),
+Billable Hours,Ore Billable,
+Billed,Facturat,
+Billed Amount,Sumă facturată,
+Billing,Facturare,
+Billing Address,Adresa De Facturare,
+Billing Address is same as Shipping Address,Adresa de facturare este aceeași cu adresa de expediere,
+Billing Amount,Suma de facturare,
+Billing Status,Stare facturare,
+Billing currency must be equal to either default company's currency or party account currency,"Valuta de facturare trebuie să fie identica fie cu valuta implicită a companiei, fie cu moneda contului de partid",
+Bills raised by Suppliers.,Facturi cu valoarea ridicată de către furnizori.,
+Bills raised to Customers.,Facturi cu valoarea ridicată pentru clienți.,
+Biotechnology,Biotehnologie,
+Birthday Reminder,Amintirea zilei de naștere,
+Black,Negru,
+Blanket Orders from Costumers.,Comenzi cuverturi de la clienți.,
+Block Invoice,Blocați factura,
+Boms,BOM,
+Bonus Payment Date cannot be a past date,Data de plată Bonus nu poate fi o dată trecută,
+Both Trial Period Start Date and Trial Period End Date must be set,"Trebuie să fie setată atât data de începere a perioadei de încercare, cât și data de încheiere a perioadei de încercare",
+Both Warehouse must belong to same Company,Ambele Depozite trebuie să aparțină aceleiași companii,
+Branch,ramură,
+Broadcasting,Transminiune,
+Brokerage,brokeraj,
+Browse BOM,Navigare BOM,
+Budget Against,Buget împotriva,
+Budget List,Lista de bugete,
+Budget Variance Report,Raport de variaţie buget,
+Budget cannot be assigned against Group Account {0},Buget nu pot fi atribuite în Grupa Contul {0},
+"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Bugetul nu pot fi atribuite în {0}, deoarece nu este un cont venituri sau cheltuieli",
+Buildings,Corpuri,
+Bundle items at time of sale.,Set de articole în momemntul vânzării.,
+Business Development Manager,Manager pentru Dezvoltarea Afacerilor,
+Buy,A cumpara,
+Buying,Cumpărare,
+Buying Amount,Sumă de cumpărare,
+Buying Price List,Achiziționarea listei de prețuri,
+Buying Rate,Rata de cumparare,
+"Buying must be checked, if Applicable For is selected as {0}","Destinat Cumpărării trebuie să fie bifat, dacă Se Aplica Pentru este selectat ca şi {0}",
+By {0},Până la {0},
+Bypass credit check at Sales Order ,Anulați verificarea creditului la Ordin de vânzări,
+C-Form records,Înregistrări formular-C,
+C-form is not applicable for Invoice: {0},Formularul C nu se aplică pentru factură: {0},
+CEO,CEO,
+CESS Amount,Suma CESS,
+CGST Amount,Suma CGST,
+CRM,CRM,
+CWIP Account,Contul CWIP,
+Calculated Bank Statement balance,Calculat Bank echilibru Declaratie,
+Calls,apeluri,
+Campaign,Campanie,
+Can be approved by {0},Poate fi aprobat/a de către {0},
+"Can not filter based on Account, if grouped by Account","Nu se poate filtra pe baza de cont, în cazul gruparii in functie de Cont",
+"Can not filter based on Voucher No, if grouped by Voucher","Nu se poate filtra pe baza voucher Nr., în cazul gruparii in functie de Voucher",
+"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Nu se poate marca evacuarea inpatientului, există facturi neachitate {0}",
+Can only make payment against unbilled {0},Plata se poate efectua numai în cazul factrilor neachitate {0},
+Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Se poate face referire la inregistrare numai dacă tipul de taxa este 'Suma inregistrare precedenta' sau 'Total inregistrare precedenta',
+"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Metoda de evaluare nu poate fi schimbată, deoarece există tranzacții împotriva anumitor elemente care nu au metoda de evaluare proprie",
+Can't create standard criteria. Please rename the criteria,Nu se pot crea criterii standard. Renunțați la criterii,
+Cancel,Anulează,
+Cancel Material Visit {0} before cancelling this Warranty Claim,Anulează Stivuitoare Vizitați {0} înainte de a anula acest revendicarea Garanție,
+Cancel Material Visits {0} before cancelling this Maintenance Visit,Anuleaza Vizite Material {0} înainte de a anula această Vizita de întreținere,
+Cancel Subscription,Anulează Abonament,
+Cancel the journal entry {0} first,Anulați mai întâi înregistrarea jurnalului {0},
+Canceled,Anulat,
+"Cannot Submit, Employees left to mark attendance","Nu se poate trimite, Angajații lăsați să marcheze prezența",
+Cannot be a fixed asset item as Stock Ledger is created.,"Nu poate fi un element de activ fix, deoarece este creat un registru de stoc.",
+Cannot cancel because submitted Stock Entry {0} exists,"Nu pot anula, deoarece a prezentat Bursa de intrare {0} există",
+Cannot cancel transaction for Completed Work Order.,Nu se poate anula tranzacția pentru comanda finalizată de lucru.,
+Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},Nu se poate anula {0} {1} deoarece numărul de serie {2} nu aparține depozitului {3},
+Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Nu se poate modifica atributele după tranzacția de stoc. Creați un element nou și transferați stocul la noul element,
+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 Service Stop Date for item in row {0},Nu se poate schimba data de începere a serviciului pentru elementul din rândul {0},
+Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Nu se pot modifica proprietățile Variant după tranzacția stoc. Va trebui să faceți un nou element pentru a face acest lucru.,
+"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Nu se poate schimba moneda implicita a companiei, deoarece există tranzacții in desfasurare. Tranzacțiile trebuie să fie anulate pentru a schimba moneda implicita.",
+Cannot change status as student {0} is linked with student application {1},Nu se poate schimba statutul de student ca {0} este legat cu aplicația de student {1},
+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 Account Type is selected.,Nu se poate sub acoperire la Grupul pentru că este selectată Tip cont.,
+Cannot create Retention Bonus for left Employees,Nu se poate crea Bonus de retenție pentru angajații stânga,
+Cannot create a Delivery Trip from Draft documents.,Nu se poate crea o călătorie de livrare din documentele Draft.,
+Cannot deactivate or cancel BOM as it is linked with other BOMs,"Nu se poate deactiva sau anula FDM, deoarece este conectat cu alte FDM-uri",
+"Cannot declare as lost, because Quotation has been made.","Nu se poate declara pierdut, pentru că Oferta a fost realizata.",
+Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Nu se poate deduce când categoria este de 'Evaluare' sau 'Evaluare și total',
+Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Nu se poate deduce atunci când este categoria de &quot;evaluare&quot; sau &quot;Vaulation și Total&quot;,
+"Cannot delete Serial No {0}, as it is used in stock transactions","Nu se poate șterge de serie nr {0}, așa cum este utilizat în tranzacțiile bursiere",
+Cannot enroll more than {0} students for this student group.,Nu se poate inscrie mai mult de {0} studenți pentru acest grup de studenți.,
+Cannot find active Leave Period,Nu se poate găsi perioada activă de plecare,
+Cannot produce more Item {0} than Sales Order quantity {1},Nu se pot produce mai multe Articole {0} decât cantitatea din Ordinul de Vânzări {1},
+Cannot promote Employee with status Left,Nu puteți promova angajatul cu starea Stânga,
+Cannot refer row number greater than or equal to current row number for this Charge type,Nu se poate face referire la un număr de inregistare mai mare sau egal cu numărul curent de inregistrare pentru acest tip de Incasare,
+Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Nu se poate selecta tipul de incasare ca 'Suma inregistrare precedenta' sau 'Total inregistrare precedenta' pentru prima inregistrare,
+Cannot set as Lost as Sales Order is made.,Nu se poate seta pierdut deoarece se intocmeste comandă de vânzări.,
+Cannot set authorization on basis of Discount for {0},Nu se poate seta autorizare pe baza de Discount pentru {0},
+Cannot set multiple Item Defaults for a company.,Nu se pot seta mai multe setări implicite pentru o companie.,
+Cannot set quantity less than delivered quantity,Cantitatea nu poate fi mai mică decât cea livrată,
+Cannot set quantity less than received quantity,Cantitatea nu poate fi mai mică decât cea primită,
+Cannot set the field <b>{0}</b> for copying in variants,Nu se poate seta câmpul <b>{0}</b> pentru copiere în variante,
+Cannot transfer Employee with status Left,Nu se poate transfera angajatul cu starea Stânga,
+Cannot {0} {1} {2} without any negative outstanding invoice,Nu se poate {0} {1} {2} in lipsa unei facturi negative restante,
+Capital Equipments,Echipamente de capital,
+Capital Stock,Capital Stock,
+Capital Work in Progress,Capitalul în curs de desfășurare,
+Cart,Coș,
+Cart is Empty,Cosul este gol,
+Case No(s) already in use. Try from Case No {0},Cazul nr. (s) este deja utilizat. Încercați din cazul nr. {s},
+Cash,Numerar,
+Cash Flow Statement,Situația fluxurilor de trezorerie,
+Cash Flow from Financing,Cash Flow de la finanțarea,
+Cash Flow from Investing,Cash Flow de la Investiții,
+Cash Flow from Operations,Cash Flow din Operațiuni,
+Cash In Hand,Bani în mână,
+Cash or Bank Account is mandatory for making payment entry,Pentru a face o inregistrare de plată este obligatoriu numerar sau cont bancar,
+Cashier Closing,Încheierea caselor,
+Casual Leave,Concediu Aleator,
+Category,Categorie,
+Category Name,Nume Categorie,
+Caution,Prudență,
+Central Tax,Impozitul central,
+Certification,Certificare,
+Cess,CESS,
+Change Amount,Sumă schimbare,
+Change Item Code,Modificați codul elementului,
+Change Release Date,Modificați data de lansare,
+Change Template Code,Schimbați codul de șablon,
+Changing Customer Group for the selected Customer is not allowed.,Schimbarea Grupului de Clienți pentru Clientul selectat nu este permisă.,
+Chapter,Capitol,
+Chapter information.,Informații despre capitol.,
+Charge of type 'Actual' in row {0} cannot be included in Item Rate,"Taxa de tip 'Efectiv' în inregistrarea {0} nu poate fi inclus în Rata Articol""",
+Chargeble,Chargeble,
+Charges are updated in Purchase Receipt against each item,Tarifele sunt actualizate în Primirea cumparare pentru fiecare articol,
+"Charges will be distributed proportionately based on item qty or amount, as per your selection","Taxele vor fi distribuite proporțional în funcție de produs Cantitate sau valoarea, ca pe dvs. de selecție",
+Chart of Cost Centers,Diagramă Centre de Cost,
+Check all,Selectați toate,
+Checkout,Verifică,
+Chemical,Chimic,
+Cheque,Cec,
+Cheque/Reference No,Cecul / de referință nr,
+Cheques Required,Verificări necesare,
+Cheques and Deposits incorrectly cleared,Cecuri și Depozite respingă incorect,
+Child Task exists for this Task. You can not delete this Task.,Sarcina pentru copii există pentru această sarcină. Nu puteți șterge această activitate.,
+Child nodes can be only created under 'Group' type nodes,noduri pentru copii pot fi create numai în noduri de tip &quot;grup&quot;,
+Child warehouse exists for this warehouse. You can not delete this warehouse.,Există depozit copil pentru acest depozit. Nu puteți șterge acest depozit.,
+Circular Reference Error,Eroare de referință Circular,
+City,Oraș,
+City/Town,Oras/Localitate,
+Claimed Amount,Suma solicitată,
+Clay,Lut,
+Clear filters,Șterge filtrele,
+Clear values,Valori clare,
+Clearance Date,Data Aprobare,
+Clearance Date not mentioned,Data Aprobare nespecificata,
+Clearance Date updated,Clearance-ul Data actualizat,
+Client,Client,
+Client ID,ID-ul clientului,
+Client Secret,Secret Client,
+Clinical Procedure,Procedura clinică,
+Clinical Procedure Template,Formularul procedurii clinice,
+Close Balance Sheet and book Profit or Loss.,Inchideti Bilanțul și registrul Profit sau Pierdere.,
+Close Loan,Împrumut închis,
+Close the POS,Închideți POS,
+Closed,Închis,
+Closed order cannot be cancelled. Unclose to cancel.,Pentru închis nu poate fi anulată. Pentru a anula redeschide.,
+Closing (Cr),De închidere (Cr),
+Closing (Dr),De închidere (Dr),
+Closing (Opening + Total),Închidere (Deschidere + Total),
+Closing Account {0} must be of type Liability / Equity,Contul {0} de închidere trebuie să fie de tip răspunderii / capitaluri proprii,
+Closing Balance,Soldul de încheiere,
+Code,Cod,
+Collapse All,Reduceți totul În această,
+Color,Culoare,
+Colour,Culoare,
+Combined invoice portion must equal 100%,Partea facturată combinată trebuie să fie egală cu 100%,
+Commercial,Comercial,
+Commission,Comision,
+Commission Rate %,Rata comisionului %,
+Commission on Sales,Comision pentru Vânzări,
+Commission rate cannot be greater than 100,Rata de comision nu poate fi mai mare decat 100,
+Community Forum,Community Forum,
+Company (not Customer or Supplier) master.,Directorul Companiei(nu al Clientului sau al Furnizorui).,
+Company Abbreviation,Abreviere Companie,
+Company Abbreviation cannot have more than 5 characters,Abrevierea companiei nu poate avea mai mult de 5 caractere,
+Company Name,Denumire Furnizor,
+Company Name cannot be Company,Numele Companiei nu poate fi Companie,
+Company currencies of both the companies should match for Inter Company Transactions.,Monedele companiilor ambelor companii ar trebui să se potrivească cu tranzacțiile Inter-Company.,
+Company is manadatory for company account,Compania este managerială pentru contul companiei,
+Company name not same,Numele companiei nu este același,
+Company {0} does not exist,Firma {0} nu există,
+Compensatory Off,Fara Masuri Compensatorii,
+Compensatory leave request days not in valid holidays,Plățile compensatorii pleacă în zilele de sărbători valabile,
+Complaint,Reclamație,
+Completion Date,Data Finalizare,
+Computer,Computer,
+Condition,Condiție,
+Configure,Configurarea,
+Configure {0},Configurare {0},
+Confirmed orders from Customers.,Comenzi confirmate de la clienți.,
+Connect Amazon with ERPNext,Conectați-vă la Amazon cu ERPNext,
+Connect Shopify with ERPNext,Conectați-vă la Shopify cu ERPNext,
+Connect to Quickbooks,Conectați-vă la agendele rapide,
+Connected to QuickBooks,Conectat la QuickBooks,
+Connecting to QuickBooks,Conectarea la QuickBooks,
+Consultation,Consultare,
+Consultations,consultări,
+Consulting,Consilia,
+Consumable,Consumabile,
+Consumed,Consumat,
+Consumed Amount,Consumat Suma,
+Consumed Qty,Cantitate consumată,
+Consumer Products,Produse consumator,
+Contact,Persoana de Contact,
+Contact Details,Detalii Persoana de Contact,
+Contact Number,Numar de contact,
+Contact Us,Contacteaza-ne,
+Content,Continut,
+Content Masters,Maeștri de conținut,
+Content Type,Tip Conținut,
+Continue Configuration,Continuați configurarea,
+Contract,Contract,
+Contract End Date must be greater than Date of Joining,Data de Incheiere Contract trebuie să fie ulterioara Datei Aderării,
+Contribution %,Contribuția%,
+Contribution Amount,Contribuția Suma,
+Conversion factor for default Unit of Measure must be 1 in row {0},Factor de Conversie pentru Unitatea de Măsură implicita trebuie să fie 1 pentru inregistrarea {0},
+Conversion rate cannot be 0 or 1,Rata de conversie nu poate fi 0 sau 1,
+Convert to Group,Transformă în grup,
+Convert to Non-Group,Converti la non-Group,
+Cosmetics,Cosmetică,
+Cost Center,Centrul de cost,
+Cost Center Number,Numărul centrului de costuri,
+Cost Center and Budgeting,Centrul de costuri și buget,
+Cost Center is required in row {0} in Taxes table for type {1},Centrul de Cost este necesar pentru inregistrarea {0} din tabelul Taxe pentru tipul {1},
+Cost Center with existing transactions can not be converted to group,Centrul de Cost cu tranzacții existente nu poate fi transformat în grup,
+Cost Center with existing transactions can not be converted to ledger,Centrul de Cost cu tranzacții existente nu poate fi transformat în registru contabil,
+Cost Centers,Centre de cost,
+Cost Updated,Cost actualizat,
+Cost as on,Cost cu o schimbare ca pe,
+Cost of Delivered Items,Costul de articole livrate,
+Cost of Goods Sold,Cost Bunuri Vândute,
+Cost of Issued Items,Costul de articole emise,
+Cost of New Purchase,Costul de achiziție nouă,
+Cost of Purchased Items,Costul de produsele cumparate,
+Cost of Scrapped Asset,Costul de active scoase din uz,
+Cost of Sold Asset,Costul de active vândute,
+Cost of various activities,Costul diverse activități,
+"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Nu s-a putut crea Nota de credit în mod automat, debifați &quot;Notați nota de credit&quot; și trimiteți-o din nou",
+Could not generate Secret,Nu am putut genera secret,
+Could not retrieve information for {0}.,Nu s-au putut obține informații pentru {0}.,
+Could not solve criteria score function for {0}. Make sure the formula is valid.,Nu s-a putut rezolva funcția de evaluare a criteriilor pentru {0}. Asigurați-vă că formula este validă.,
+Could not solve weighted score function. Make sure the formula is valid.,Nu s-a putut rezolva funcția de scor ponderat. Asigurați-vă că formula este validă.,
+Could not submit some Salary Slips,Nu am putut trimite unele Salariile,
+"Could not update stock, invoice contains drop shipping item.","Nu s-a putut actualiza stocul, factura conține elementul de expediere.",
+Country wise default Address Templates,Șabloanele țară înțelept adresa implicită,
+Course,Curs,
+Course Code: ,Codul cursului:,
+Course Enrollment {0} does not exists,Înscrierea la curs {0} nu există,
+Course Schedule,Program de curs de,
+Course: ,Curs:,
+Cr,Cr,
+Create,Creează,
+Create BOM,Creați BOM,
+Create Delivery Trip,Creați călătorie de livrare,
+Create Disbursement Entry,Creați intrare pentru dezbursare,
+Create Employee,Creați angajat,
+Create Employee Records,Crearea angajaților Records,
+"Create Employee records to manage leaves, expense claims and payroll","Crearea de înregistrări angajaților pentru a gestiona frunze, cheltuieli și salarizare creanțe",
+Create Fee Schedule,Creați programul de taxe,
+Create Fees,Creați taxe,
+Create Inter Company Journal Entry,Creați jurnalul companiei Inter,
+Create Invoice,Creați factură,
+Create Invoices,Creați facturi,
+Create Job Card,Creați carte de muncă,
+Create Journal Entry,Creați intrarea în jurnal,
+Create Lead,Creați Lead,
+Create Leads,Creează Piste,
+Create Maintenance Visit,Creați vizită de întreținere,
+Create Material Request,Creați solicitare de materiale,
+Create Multiple,Creați mai multe,
+Create Opening Sales and Purchase Invoices,Creați deschiderea vânzărilor și facturilor de achiziție,
+Create Payment Entries,Creați intrări de plată,
+Create Payment Entry,Creați intrare de plată,
+Create Print Format,Creați Format imprimare,
+Create Purchase Order,Creați comanda de aprovizionare,
+Create Purchase Orders,Creare comenzi de aprovizionare,
+Create Quotation,Creare Ofertă,
+Create Salary Slip,Crea Fluturasul de Salariul,
+Create Salary Slips,Creați buletine de salariu,
+Create Sales Invoice,Creați factură de vânzări,
+Create Sales Order,Creați o comandă de vânzări,
+Create Sales Orders to help you plan your work and deliver on-time,Creați comenzi de vânzare pentru a vă ajuta să vă planificați munca și să vă livrați la timp,
+Create Sample Retention Stock Entry,Creați intrare de stoc de reținere a eșantionului,
+Create Student,Creați student,
+Create Student Batch,Creați lot de elevi,
+Create Student Groups,Creați Grupurile de studenți,
+Create Supplier Quotation,Creați ofertă pentru furnizori,
+Create Tax Template,Creați șablonul fiscal,
+Create Timesheet,Creați o foaie de lucru,
+Create User,Creaza utilizator,
+Create Users,Creați utilizatori,
+Create Variant,Creați varianta,
+Create Variants,Creați variante,
+"Create and manage daily, weekly and monthly email digests.","Creare și gestionare rezumate e-mail zilnice, săptămânale și lunare.",
+Create customer quotes,Creați citate client,
+Create rules to restrict transactions based on values.,Creare reguli pentru restricționare tranzacții bazate pe valori.,
+Created {0} scorecards for {1} between: ,A creat {0} cărți de scor pentru {1} între:,
+Creating Company and Importing Chart of Accounts,Crearea companiei și importul graficului de conturi,
+Creating Fees,Crearea de taxe,
+Creating Payment Entries......,Crearea intrărilor de plată ......,
+Creating Salary Slips...,Crearea salvărilor salariale ...,
+Creating student groups,Crearea grupurilor de studenți,
+Creating {0} Invoice,Crearea facturii {0},
+Credit,Credit,
+Credit ({0}),Credit ({0}),
+Credit Account,Cont de credit,
+Credit Balance,Balanța de credit,
+Credit Card,Card de credit,
+Credit Days cannot be a negative number,Zilele de credit nu pot fi un număr negativ,
+Credit Limit,Limita de credit,
+Credit Note,Nota de credit,
+Credit Note Amount,Nota de credit Notă,
+Credit Note Issued,Nota de credit Eliberat,
+Credit Note {0} has been created automatically,Nota de credit {0} a fost creată automat,
+Credit limit has been crossed for customer {0} ({1}/{2}),Limita de credit a fost depășită pentru clientul {0} ({1} / {2}),
+Creditors,creditorii,
+Criteria weights must add up to 100%,Criteriile de greutate trebuie să adauge până la 100%,
+Crop Cycle,Ciclu de recoltare,
+Crops & Lands,Culturi și terenuri,
+Currency Exchange must be applicable for Buying or for Selling.,Cursul valutar trebuie să fie aplicabil pentru cumpărare sau pentru vânzare.,
+Currency can not be changed after making entries using some other currency,Moneda nu poate fi schimbat după efectuarea înregistrări folosind un altă valută,
+Currency exchange rate master.,Maestru cursului de schimb valutar.,
+Currency for {0} must be {1},Moneda pentru {0} trebuie să fie {1},
+Currency is required for Price List {0},Moneda este necesară pentru lista de prețuri {0},
+Currency of the Closing Account must be {0},Valuta contului de închidere trebuie să fie {0},
+Currency of the price list {0} must be {1} or {2},Moneda din lista de prețuri {0} trebuie să fie {1} sau {2},
+Currency should be same as Price List Currency: {0},Valuta trebuie sa fie aceeasi cu Moneda Preturilor: {0},
+Current,Actual,
+Current Assets,Active curente,
+Current BOM and New BOM can not be same,FDM-ul curent și FDM-ul nou nu pot fi identici,
+Current Job Openings,Locuri de munca disponibile,
+Current Liabilities,Raspunderi Curente,
+Current Qty,Cantitate curentă,
+Current invoice {0} is missing,Factura curentă {0} lipsește,
+Custom HTML,Personalizat HTML,
+Custom?,Personalizat?,
+Customer,Client,
+Customer Addresses And Contacts,Adrese de clienți și Contacte,
+Customer Contact,Clientul A lua legatura,
+Customer Database.,Baza de Date Client.,
+Customer Group,Grup Clienți,
+Customer LPO,Clientul LPO,
+Customer LPO No.,Client nr. LPO,
+Customer Name,Nume client,
+Customer POS Id,ID POS utilizator,
+Customer Service,Service Client,
+Customer and Supplier,Client și Furnizor,
+Customer is required,Clientul este necesar,
+Customer isn't enrolled in any Loyalty Program,Clientul nu este înscris în niciun program de loialitate,
+Customer required for 'Customerwise Discount',Client necesar pentru 'Reducere Client',
+Customer {0} does not belong to project {1},Clientul {0} nu aparține proiectului {1},
+Customer {0} is created.,Clientul {0} este creat.,
+Customers in Queue,Clienții din coadă,
+Customize Homepage Sections,Personalizați secțiunile homepage,
+Customizing Forms,Personalizare Formulare,
+Daily Project Summary for {0},Rezumatul zilnic al proiectului pentru {0},
+Daily Reminders,Memento de zi cu zi,
+Daily Work Summary,Sumar Zilnic de Lucru,
+Daily Work Summary Group,Grup de lucru zilnic de lucru,
+Data Import and Export,Datele de import și export,
+Data Import and Settings,Import de date și setări,
+Database of potential customers.,Bază de date cu clienți potențiali.,
+Date Format,Format Dată,
+Date Of Retirement must be greater than Date of Joining,Data Pensionare trebuie să fie ulterioara Datei Aderării,
+Date is repeated,Data se repetă,
+Date of Birth,Data Nașterii,
+Date of Birth cannot be greater than today.,Data Nașterii nu poate fi mai mare decât în prezent.,
+Date of Commencement should be greater than Date of Incorporation,Data de Începere ar trebui să fie mai mare decât data înființării,
+Date of Joining,Data aderării,
+Date of Joining must be greater than Date of Birth,Data Aderării trebuie să fie ulterioara Datei Nașterii,
+Date of Transaction,Data tranzacției,
+Datetime,DatăTimp,
+Day,Zi,
+Debit,Debit,
+Debit ({0}),Debit ({0}),
+Debit A/C Number,Număr de debit A / C,
+Debit Account,Cont Debit,
+Debit Note,Notă Debit,
+Debit Note Amount,Sumă Notă Debit,
+Debit Note Issued,Notă Debit Eliberată,
+Debit To is required,Pentru debit este necesar,
+Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debit și credit nu este egal pentru {0} # {1}. Diferența este {2}.,
+Debtors,Debitori,
+Debtors ({0}),Debitorilor ({0}),
+Declare Lost,Declar pierdut,
+Deduction,Deducere,
+Default Activity Cost exists for Activity Type - {0},Există implicit Activitate Cost de activitate de tip - {0},
+Default BOM ({0}) must be active for this item or its template,Implicit BOM ({0}) trebuie să fie activ pentru acest element sau șablon de,
+Default BOM for {0} not found,BOM implicit pentru {0} nu a fost găsit,
+Default BOM not found for Item {0} and Project {1},Implicit BOM nu a fost găsit pentru articolele {0} și proiectul {1},
+Default Letter Head,Implicit Scrisoare Șef,
+Default Tax Template,Implicit Template fiscal,
+Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Unitatea de măsură implicită pentru postul {0} nu poate fi schimbat direct, deoarece aveti si voi deja unele tranzacții (i) cu un alt UOM. Veți avea nevoie pentru a crea un nou element pentru a utiliza un alt implicit UOM.",
+Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Unitatea implicit de măsură pentru Variant &#39;{0} &quot;trebuie să fie la fel ca în Template&quot; {1} &quot;,
+Default settings for buying transactions.,Setări implicite pentru tranzacțiilor de achizitie.,
+Default settings for selling transactions.,Setări implicite pentru tranzacțiile de vânzare.,
+Default tax templates for sales and purchase are created.,Se creează șabloane fiscale predefinite pentru vânzări și achiziții.,
+Defaults,Implicite,
+Defense,Apărare,
+Define Project type.,Definiți tipul de proiect.,
+Define budget for a financial year.,Definiți bugetul pentru un exercițiu financiar.,
+Define various loan types,Definirea diferitelor tipuri de împrumut,
+Del,del,
+Delay in payment (Days),Întârziere de plată (zile),
+Delete all the Transactions for this Company,Ștergeți toate tranzacțiile de acest companie,
+Deletion is not permitted for country {0},Ștergerea nu este permisă pentru țara {0},
+Delivered,Livrat,
+Delivered Amount,Suma Pronunțată,
+Delivered Qty,Cantitate Livrata,
+Delivered: {0},Livrate: {0},
+Delivery,Livrare,
+Delivery Date,Data de Livrare,
+Delivery Note,Nota de Livrare,
+Delivery Note {0} is not submitted,Nota de Livrare {0} nu este introdusa,
+Delivery Note {0} must not be submitted,Nota de Livrare {0} nu trebuie sa fie introdusa,
+Delivery Notes {0} must be cancelled before cancelling this Sales Order,Nota de Livrare {0} trebuie sa fie anulată înainte de a anula aceasta Comandă de Vânzări,
+Delivery Notes {0} updated,Notele de livrare {0} sunt actualizate,
+Delivery Status,Starea de Livrare,
+Delivery Trip,Excursie la expediere,
+Delivery warehouse required for stock item {0},Depozit de livrare necesar pentru articol stoc {0},
+Department,Departament,
+Department Stores,Magazine Departament,
+Depreciation,Depreciere,
+Depreciation Amount,Sumă de amortizare,
+Depreciation Amount during the period,Suma de amortizare în timpul perioadei,
+Depreciation Date,Data de amortizare,
+Depreciation Eliminated due to disposal of assets,Amortizare Eliminată din cauza eliminării activelor,
+Depreciation Entry,amortizare intrare,
+Depreciation Method,Metoda de amortizare,
+Depreciation Row {0}: Depreciation Start Date is entered as past date,Rândul de amortizare {0}: Data de începere a amortizării este introdusă ca dată trecută,
+Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Rata de amortizare {0}: Valoarea estimată după viața utilă trebuie să fie mai mare sau egală cu {1},
+Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Rândul de amortizare {0}: Data următoarei amortizări nu poate fi înaintea datei disponibile pentru utilizare,
+Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Rata de amortizare {0}: Data următoare a amortizării nu poate fi înainte de data achiziției,
+Designer,proiectant,
+Detailed Reason,Motiv detaliat,
+Details,Detalii,
+Details of Outward Supplies and inward supplies liable to reverse charge,"Detalii despre consumabile externe și consumabile interioare, care pot fi percepute invers",
+Details of the operations carried out.,Detalii privind operațiunile efectuate.,
+Diagnosis,Diagnostic,
+Did not find any item called {0},Nu am gasit nici un element numit {0},
+Diff Qty,Cantitate diferențială,
+Difference Account,Diferența de Cont,
+"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Diferența cont trebuie să fie un cont de tip activ / pasiv, deoarece acest stoc Reconcilierea este un intrare de deschidere",
+Difference Amount,Diferență Sumă,
+Difference Amount must be zero,Diferența Suma trebuie să fie zero,
+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.,Un UOM diferit pentru articole va conduce la o valoare incorecta pentru Greutate Neta (Total). Asigurați-vă că Greutatea Netă a fiecărui articol este în același UOM.,
+Direct Expenses,Cheltuieli directe,
+Direct Income,Venituri Directe,
+Disable,Dezactivați,
+Disabled template must not be default template,șablon cu handicap nu trebuie să fie șablon implicit,
+Disburse Loan,Împrumut de debit,
+Disbursed,debursate,
+Disc,Disc,
+Discharge,descărcare,
+Discount,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,Reducerea trebuie să fie mai mică de 100,
+Diseases & Fertilizers,Boli și îngrășăminte,
+Dispatch,Expediere,
+Dispatch Notification,Notificare de expediere,
+Dispatch State,Statul de expediere,
+Distance,Distanţă,
+Distribution,distribuire,
+Distributor,Distribuitor,
+Dividends Paid,Dividendele plătite,
+Do you really want to restore this scrapped asset?,Sigur doriți să restabiliți acest activ casate?,
+Do you really want to scrap this asset?,Chiar vrei să resturi acest activ?,
+Do you want to notify all the customers by email?,Doriți să notificăți toți clienții prin e-mail?,
+Doc Date,Data Documentelor,
+Doc Name,Denumire Doc,
+Doc Type,Tip Doc,
+Docs Search,Căutare în Docs,
+Document Name,Document Nume,
+Document Status,Stare Document,
+Document Type,Tip Document,
+Domain,Domeniu,
+Domains,Domenii,
+Done,Făcut,
+Donor,Donator,
+Donor Type information.,Informații tip donator.,
+Donor information.,Informații despre donator.,
+Download JSON,Descărcați JSON,
+Draft,Proiect,
+Drop Ship,Drop navelor,
+Drug,Medicament,
+Due / Reference Date cannot be after {0},Datorită / Reference Data nu poate fi după {0},
+Due Date cannot be before Posting / Supplier Invoice Date,Data scadentă nu poate fi înainte de data de înregistrare / factură a furnizorului,
+Due Date is mandatory,Due Date este obligatorie,
+Duplicate Entry. Please check Authorization Rule {0},Inregistrare Duplicat. Vă rugăm să verificați Regula de Autorizare {0},
+Duplicate Serial No entered for Item {0},Nr. Serial introdus pentru articolul {0} este duplicat,
+Duplicate customer group found in the cutomer group table,grup de clienți dublu exemplar găsit în tabelul grupului cutomer,
+Duplicate entry,Inregistrare duplicat,
+Duplicate item group found in the item group table,Grup de element dublu exemplar găsit în tabelul de grup de elemente,
+Duplicate roll number for student {0},Numărul de rolă duplicat pentru student {0},
+Duplicate row {0} with same {1},Inregistrare {0} este duplicata cu aceeași {1},
+Duplicate {0} found in the table,Duplicat {0} găsit în tabel,
+Duration in Days,Durata în Zile,
+Duties and Taxes,Impozite și taxe,
+E-Invoicing Information Missing,Informații privind facturarea electronică lipsă,
+ERPNext Demo,ERPNext Demo,
+ERPNext Settings,Setări ERPNext,
+Earliest,cel mai devreme,
+Earnest Money,Banii cei mai castigati,
+Earning,Câștig Salarial,
+Edit,Editați | ×,
+Edit Publishing Details,Editați detaliile publicării,
+"Edit in full page for more options like assets, serial nos, batches etc.","Modificați pe pagina completă pentru mai multe opțiuni, cum ar fi active, numere de serie, loturi etc.",
+Education,Educaţie,
+Either location or employee must be required,Trebuie să fie necesară locația sau angajatul,
+Either target qty or target amount is mandatory,Cantitatea țintă sau valoarea țintă este obligatorie,
+Either target qty or target amount is mandatory.,Cantitatea țintă sau valoarea țintă este obligatorie.,
+Electrical,Electric,
+Electronic Equipments,Echipamente electronice,
+Electronics,Electronică,
+Eligible ITC,ITC eligibil,
+Email Account,Contul de e-mail,
+Email Address,Adresa de email,
+"Email Address must be unique, already exists for {0}","Adresa de e-mail trebuie să fie unic, există deja pentru {0}",
+Email Digest: ,Email Digest:,
+Email Reminders will be sent to all parties with email contacts,Mementourile de e-mail vor fi trimise tuturor părților cu contacte de e-mail,
+Email Sent,E-mail trimis,
+Email Template,Șablon de e-mail,
+Email not found in default contact,E-mailul nu a fost găsit în contactul implicit,
+Email sent to {0},E-mail trimis la {0},
+Employee,Angajat,
+Employee A/C Number,Numărul A / C al angajaților,
+Employee Advances,Avansuri ale angajaților,
+Employee Benefits,Beneficiile angajatului,
+Employee Grade,Clasa angajatilor,
+Employee ID,card de identitate al angajatului,
+Employee Lifecycle,Durata de viață a angajatului,
+Employee Name,Nume angajat,
+Employee Promotion cannot be submitted before Promotion Date ,Promovarea angajaților nu poate fi depusă înainte de data promoției,
+Employee Referral,Referirea angajaților,
+Employee Transfer cannot be submitted before Transfer Date ,Transferul angajaților nu poate fi depus înainte de data transferului,
+Employee cannot report to himself.,Angajat nu pot raporta la sine.,
+Employee relieved on {0} must be set as 'Left',Angajat eliberat din finctie pe {0} trebuie să fie setat ca 'Plecat',
+Employee {0} already submited an apllication {1} for the payroll period {2},Angajatul {0} a trimis deja o aplicație {1} pentru perioada de plată {2},
+Employee {0} has already applied for {1} between {2} and {3} : ,Angajatul {0} a solicitat deja {1} între {2} și {3}:,
+Employee {0} has no maximum benefit amount,Angajatul {0} nu are o valoare maximă a beneficiului,
+Employee {0} is not active or does not exist,Angajatul {0} nu este activ sau nu există,
+Employee {0} is on Leave on {1},Angajatul {0} este activat Lăsați pe {1},
+Employee {0} of grade {1} have no default leave policy,Angajații {0} ai clasei {1} nu au o politică de concediu implicită,
+Employee {0} on Half day on {1},Angajat {0} pe jumătate de zi pe {1},
+Enable,Activare,
+Enable / disable currencies.,Activare / dezactivare valute.,
+Enabled,Activat,
+"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Dacă activați opțiunea &quot;Utilizare pentru Cos de cumparaturi &#39;, ca Cosul de cumparaturi este activat și trebuie să existe cel puțin o regulă fiscală pentru Cos de cumparaturi",
+End Date,Dată finalizare,
+End Date can not be less than Start Date,Data de încheiere nu poate fi mai mică decât data de începere,
+End Date cannot be before Start Date.,Data de încheiere nu poate fi înainte de data de începere.,
+End Year,Anul de încheiere,
+End Year cannot be before Start Year,Sfârșitul anului nu poate fi înainte de Anul de început,
+End on,Terminați,
+End time cannot be before start time,Ora de încheiere nu poate fi înainte de ora de începere,
+Ends On date cannot be before Next Contact Date.,Sfârșitul de data nu poate fi înaintea datei următoarei persoane de contact.,
+Energy,Energie,
+Engineer,Inginer,
+Enough Parts to Build,Piese de schimb suficient pentru a construi,
+Enroll,A se inscrie,
+Enrolling student,student inregistrat,
+Enrolling students,Înscrierea studenților,
+Enter depreciation details,Introduceți detaliile de depreciere,
+Enter the Bank Guarantee Number before submittting.,Introduceți numărul de garanție bancară înainte de depunere.,
+Enter the name of the Beneficiary before submittting.,Introduceți numele Beneficiarului înainte de depunerea.,
+Enter the name of the bank or lending institution before submittting.,Introduceți numele băncii sau al instituției de credit înainte de depunere.,
+Enter value betweeen {0} and {1},Introduceți valoarea dintre {0} și {1},
+Entertainment & Leisure,Divertisment & Relaxare,
+Entertainment Expenses,Cheltuieli de Divertisment,
+Equity,echitate,
+Error Log,eroare Log,
+Error evaluating the criteria formula,Eroare la evaluarea formulei de criterii,
+Error in formula or condition: {0},Eroare în formulă sau o condiție: {0},
+Error: Not a valid id?,Eroare: Nu a id valid?,
+Estimated Cost,Cost estimat,
+Evaluation,Evaluare,
+"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:",
+Event,Eveniment,
+Event Location,Locația evenimentului,
+Event Name,Numele evenimentului,
+Exchange Gain/Loss,Cheltuiala / Venit din diferente de curs valutar,
+Exchange Rate Revaluation master.,Master reevaluarea cursului de schimb.,
+Exchange Rate must be same as {0} {1} ({2}),Cursul de schimb trebuie să fie același ca și {0} {1} ({2}),
+Excise Invoice,Factura acciza,
+Execution,Execuţie,
+Executive Search,Cautare executiva,
+Expand All,Extinde toate,
+Expected Delivery Date,Data de Livrare Preconizata,
+Expected Delivery Date should be after Sales Order Date,Data de livrare preconizată trebuie să fie după data de comandă de vânzare,
+Expected End Date,Data de Incheiere Preconizata,
+Expected Hrs,Se așteptau ore,
+Expected Start Date,Data de Incepere Preconizata,
+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,Cont de cheltuieli,
+Expense Claim,Solicitare Cheltuială,
+Expense Claim for Vehicle Log {0},Solicitare Cheltuială pentru Log Vehicul {0},
+Expense Claim {0} already exists for the Vehicle Log,Solicitare Cheltuială {0} există deja pentru Log Vehicul,
+Expense Claims,Creanțe cheltuieli,
+Expense account is mandatory for item {0},Cont de cheltuieli este obligatoriu pentru articolul {0},
+Expenses,cheltuieli,
+Expenses Included In Asset Valuation,Cheltuieli incluse în evaluarea activelor,
+Expenses Included In Valuation,Cheltuieli incluse în evaluare,
+Expired Batches,Loturile expirate,
+Expires On,Expira la,
+Expiring On,Expirând On,
+Expiry (In Days),Expirării (în zile),
+Explore,Explorați,
+Export E-Invoices,Export facturi electronice,
+Extra Large,Extra mare,
+Extra Small,Extra Small,
+Fail,eșua,
+Failed,A eșuat,
+Failed to create website,Eroare la crearea site-ului,
+Failed to install presets,Eroare la instalarea presetărilor,
+Failed to login,Eroare la autentificare,
+Failed to setup company,Setarea companiei nu a reușit,
+Failed to setup defaults,Setările prestabilite nu au reușit,
+Failed to setup post company fixtures,Nu sa reușit configurarea posturilor companiei,
+Fax,Fax,
+Fee,taxă,
+Fee Created,Taxa a fost creată,
+Fee Creation Failed,Crearea de comisioane a eșuat,
+Fee Creation Pending,Crearea taxelor în așteptare,
+Fee Records Created - {0},Taxa de inregistrare Creat - {0},
+Feedback,Reactie,
+Fees,Taxele de,
+Female,Feminin,
+Fetch Data,Fetch Data,
+Fetch Subscription Updates,Actualizați abonamentul la preluare,
+Fetch exploded BOM (including sub-assemblies),Obtine FDM expandat (inclusiv subansamblurile),
+Fetching records......,Recuperarea înregistrărilor ......,
+Field Name,Nume câmp,
+Fieldname,Nume câmp,
+Fields,Câmpuri,
+Fill the form and save it,Completați formularul și salvați-l,
+Filter Employees By (Optional),Filtrați angajații după (opțional),
+"Filter Fields Row #{0}: Fieldname <b>{1}</b> must be of type ""Link"" or ""Table MultiSelect""",Rândul câmpurilor de filtrare # {0}: Numele de câmp <b>{1}</b> trebuie să fie de tipul &quot;Link&quot; sau &quot;MultiSelect de tabel&quot;,
+Filter Total Zero Qty,Filtrați numărul total zero,
+Finance Book,Cartea de finanțe,
+Financial / accounting year.,An financiar / contabil.,
+Financial Services,Servicii financiare,
+Financial Statements,Situațiile financiare,
+Financial Year,An financiar,
+Finish,finalizarea,
+Finished Good,Terminat bine,
+Finished Good Item Code,Cod articol bun finalizat,
+Finished Goods,Produse finite,
+Finished Item {0} must be entered for Manufacture type entry,Postul terminat {0} trebuie să fie introdusă de intrare de tip fabricarea,
+Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Produsul finit <b>{0}</b> și Cantitatea <b>{1}</b> nu pot fi diferite,
+First Name,Prenume,
+"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","Regimul fiscal este obligatoriu, vă rugăm să setați regimul fiscal în companie {0}",
+Fiscal Year,An fiscal,
+Fiscal Year End Date should be one year after Fiscal Year Start Date,Data de încheiere a anului fiscal trebuie să fie un an de la data începerii anului fiscal,
+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 should be one year earlier than Fiscal Year End Date,Data de începere a anului fiscal ar trebui să fie cu un an mai devreme decât data de încheiere a anului fiscal,
+Fiscal Year {0} does not exist,Anul fiscal {0} nu există,
+Fiscal Year {0} is required,Anul fiscal {0} este necesară,
+Fiscal Year {0} not found,Anul fiscal {0} nu a fost găsit,
+Fixed Asset,Activ Fix,
+Fixed Asset Item must be a non-stock item.,Fix elementul de activ trebuie să fie un element de bază non-stoc.,
+Fixed Assets,Active Fixe,
+Following Material Requests have been raised automatically based on Item's re-order level,Ca urmare a solicitărilor de materiale au fost ridicate în mod automat în funcție de nivelul de re-comanda item,
+Following accounts might be selected in GST Settings:,Următoarele conturi ar putea fi selectate în Setări GST:,
+Following course schedules were created,Următoarele programe au fost create,
+Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Următorul articol {0} nu este marcat ca {1} element. Puteți să le activați ca element {1} din capitolul Articol,
+Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,Următoarele elemente {0} nu sunt marcate ca {1} element. Puteți să le activați ca element {1} din capitolul Articol,
+Food,Produse Alimentare,
+"Food, Beverage & Tobacco","Produse Alimentare, Bauturi si Tutun",
+For,Pentru,
+"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Pentru elementele &quot;produse Bundle&quot;, Warehouse, Serial No și lot nr vor fi luate în considerare de la &quot;ambalare List&quot; masa. Dacă Warehouse și Lot nr sunt aceleași pentru toate elementele de ambalaj pentru produs orice &quot;Bundle produs&quot;, aceste valori pot fi introduse în tabelul de punctul principal, valorile vor fi copiate &quot;de ambalare Lista&quot; masă.",
+For Employee,Pentru angajat,
+For Quantity (Manufactured Qty) is mandatory,Pentru Cantitate (fabricat Cant) este obligatorie,
+For Supplier,Pentru Furnizor,
+For Warehouse,Pentru depozit,
+For Warehouse is required before Submit,Pentru Depozit este necesar înainte de Inregistrare,
+"For an item {0}, quantity must be negative number","Pentru un element {0}, cantitatea trebuie să fie număr negativ",
+"For an item {0}, quantity must be positive number","Pentru un element {0}, cantitatea trebuie să fie un număr pozitiv",
+"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","Pentru cartea de muncă {0}, puteți înscrie doar stocul de tip „Transfer de material pentru fabricare”",
+"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Pentru rândul {0} în {1}. Pentru a include {2} ratei punctul, randuri {3} De asemenea, trebuie să fie incluse",
+For row {0}: Enter Planned Qty,Pentru rândul {0}: Introduceți cantitatea planificată,
+"For {0}, only credit accounts can be linked against another debit entry","Pentru {0}, numai conturi de credit poate fi legat de o altă intrare în debit",
+"For {0}, only debit accounts can be linked against another credit entry","Pentru {0}, numai conturi de debit poate fi legat de o altă intrare în credit",
+Forum Activity,Activitatea Forumului,
+Free item code is not selected,Codul gratuit al articolului nu este selectat,
+Freight and Forwarding Charges,Incarcatura și Taxe de Expediere,
+Frequency,Frecvență,
+Friday,Vineri,
+From,De la,
+From Address 1,De la adresa 1,
+From Address 2,Din adresa 2,
+From Currency and To Currency cannot be same,Din Valuta și In Valuta nu pot fi identice,
+From Date and To Date lie in different Fiscal Year,De la data și până la data se află în anul fiscal diferit,
+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,Din Data trebuie să fie anterioara Pana la Data,
+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 Date {0} cannot be after employee's relieving Date {1},De la data {0} nu poate fi după data eliberării angajatului {1},
+From Date {0} cannot be before employee's joining Date {1},De la data {0} nu poate fi înainte de data de îmbarcare a angajatului {1},
+From Datetime,De la Datetime,
+From Delivery Note,Din Nota de livrare,
+From Fiscal Year,Din anul fiscal,
+From GSTIN,De la GSTIN,
+From Party Name,De la numele partidului,
+From Pin Code,Din codul PIN,
+From Place,De la loc,
+From Range has to be less than To Range,Din Gama trebuie să fie mai mică de la gama,
+From State,Din stat,
+From Time,Din Time,
+From Time Should Be Less Than To Time,Din timp ar trebui să fie mai puțin decât timpul,
+From Time cannot be greater than To Time.,Din Timpul nu poate fi mai mare decât în timp.,
+"From a supplier under composition scheme, Exempt and Nil rated","De la un furnizor în regim de compoziție, Exempt și Nil au evaluat",
+From and To dates required,Datele De La și Pana La necesare,
+From date can not be less than employee's joining date,De la data nu poate fi mai mică decât data angajării angajatului,
+From value must be less than to value in row {0},Din valoare trebuie să fie mai mică decat in valoare pentru inregistrarea {0},
+From {0} | {1} {2},De la {0} | {1} {2},
+Fuel Price,Preț de combustibil,
+Fuel Qty,combustibil Cantitate,
+Fulfillment,Împlinire,
+Full,Deplin,
+Full Name,Nume complet,
+Full-time,Permanent,
+Fully Depreciated,Depreciata pe deplin,
+Furnitures and Fixtures,Furnitures și Programe,
+"Further accounts can be made under Groups, but entries can be made against non-Groups","Conturile suplimentare pot fi făcute sub Groups, dar intrările pot fi făcute împotriva non-Grupuri",
+Further cost centers can be made under Groups but entries can be made against non-Groups,"Centre de costuri pot fi realizate în grupuri, dar intrările pot fi făcute împotriva non-Grupuri",
+Further nodes can be only created under 'Group' type nodes,Noduri suplimentare pot fi create numai în noduri de tip 'Grup',
+Future dates not allowed,Datele viitoare nu sunt permise,
+GSTIN,GSTIN,
+GSTR3B-Form,GSTR3B-Form,
+Gain/Loss on Asset Disposal,Câștigul / Pierdere de eliminare a activelor,
+Gantt Chart,Diagrama Gantt,
+Gantt chart of all tasks.,Diagrama Gantt a tuturor sarcinilor.,
+Gender,Sex,
+General,General,
+General Ledger,Registru Contabil General,
+Generate Material Requests (MRP) and Work Orders.,Generează cereri de material (MRP) și comenzi de lucru.,
+Generate Secret,Generați secret,
+Get Details From Declaration,Obțineți detalii din declarație,
+Get Employees,Obțineți angajați,
+Get Invocies,Obțineți invocări,
+Get Invoices,Obțineți facturi,
+Get Invoices based on Filters,Obțineți facturi bazate pe filtre,
+Get Items from BOM,Obține articole din FDM,
+Get Items from Healthcare Services,Obțineți articole din serviciile de asistență medicală,
+Get Items from Prescriptions,Obțineți articole din prescripții,
+Get Items from Product Bundle,Obține elemente din Bundle produse,
+Get Suppliers,Obțineți furnizori,
+Get Suppliers By,Obțineți furnizori prin,
+Get Updates,Obțineți actualizări,
+Get customers from,Obțineți clienți de la,
+Get from Patient Encounter,Ia de la întâlnirea cu pacienții,
+Getting Started,Noțiuni de bază,
+GitHub Sync ID,ID-ul de sincronizare GitHub,
+Global settings for all manufacturing processes.,Setările globale pentru toate procesele de producție.,
+Go to the Desktop and start using ERPNext,Du-te la desktop și începe să utilizați ERPNext,
+GoCardless SEPA Mandate,GoCardless Mandatul SEPA,
+GoCardless payment gateway settings,Setările gateway-ului de plată GoCardless,
+Goal and Procedure,Obiectivul și procedura,
+Goals cannot be empty,Obiectivele nu poate fi gol,
+Goods In Transit,Bunuri în tranzit,
+Goods Transferred,Mărfuri transferate,
+Goods and Services Tax (GST India),Mărfuri și servicii fiscale (GST India),
+Goods are already received against the outward entry {0},Mărfurile sunt deja primite cu intrarea exterioară {0},
+Government,Guvern,
+Grand Total,Total general,
+Grant,Acorda,
+Grant Application,Cerere de finanțare nerambursabilă,
+Grant Leaves,Grant Frunze,
+Grant information.,Acordați informații.,
+Grocery,Băcănie,
+Gross Pay,Plata Bruta,
+Gross Profit,Profit brut,
+Gross Profit %,Profit Brut%,
+Gross Profit / Loss,Profit brut / Pierdere,
+Gross Purchase Amount,Sumă brută Cumpărare,
+Gross Purchase Amount is mandatory,Valoarea brută Achiziția este obligatorie,
+Group by Account,Grup in functie de Cont,
+Group by Party,Grup după partid,
+Group by Voucher,Grup in functie de Voucher,
+Group by Voucher (Consolidated),Grup după Voucher (Consolidat),
+Group node warehouse is not allowed to select for transactions,depozit nod grup nu este permis să selecteze pentru tranzacții,
+Group to Non-Group,Grup non-grup,
+Group your students in batches,Grupa elevii în loturi,
+Groups,Grupuri,
+Guardian1 Email ID,Codul de e-mail al Guardian1,
+Guardian1 Mobile No,Guardian1 mobil nr,
+Guardian1 Name,Nume Guardian1,
+Guardian2 Email ID,Codul de e-mail Guardian2,
+Guardian2 Mobile No,Guardian2 mobil nr,
+Guardian2 Name,Nume Guardian2,
+Guest,Oaspete,
+HR Manager,Manager Resurse Umane,
+HSN,HSN,
+HSN/SAC,HSN / SAC,
+Half Day,Jumătate de zi,
+Half Day Date is mandatory,Data semestrului este obligatorie,
+Half Day Date should be between From Date and To Date,Jumătate Data zi ar trebui să fie între De la data si pana in prezent,
+Half Day Date should be in between Work From Date and Work End Date,Data de la jumătate de zi ar trebui să se afle între Data de lucru și Data de terminare a lucrului,
+Half Yearly,Semestrial,
+Half day date should be in between from date and to date,Data de la jumătate de zi ar trebui să fie între data și data,
+Half-Yearly,Semestrial,
+Hardware,Hardware,
+Head of Marketing and Sales,Director de Marketing și Vânzări,
+Health Care,Servicii de Sanatate,
+Healthcare,Sănătate,
+Healthcare (beta),Servicii medicale (beta),
+Healthcare Practitioner,Medicul de îngrijire medicală,
+Healthcare Practitioner not available on {0},Medicul de îngrijire medicală nu este disponibil la {0},
+Healthcare Practitioner {0} not available on {1},Medicul de îngrijire medicală {0} nu este disponibil la {1},
+Healthcare Service Unit,Serviciul de asistență medicală,
+Healthcare Service Unit Tree,Unitatea de servicii de asistență medicală,
+Healthcare Service Unit Type,Tipul unității de servicii medicale,
+Healthcare Services,Servicii pentru sanatate,
+Healthcare Settings,Setări de asistență medicală,
+Hello,buna,
+Help Results for,Rezultate de ajutor pentru,
+High,Ridicat,
+High Sensitivity,Sensibilitate crescută,
+Hold,Păstrarea / Ţinerea / Deţinerea,
+Hold Invoice,Rețineți factura,
+Holiday,Vacanţă,
+Holiday List,Lista de vacanță,
+Hotel Rooms of type {0} are unavailable on {1},Camerele Hotel de tip {0} nu sunt disponibile în {1},
+Hotels,Hoteluri,
+Hourly,ore,
+Hours,ore,
+House rent paid days overlapping with {0},Chirie de casă zile plătite care se suprapun cu {0},
+House rented dates required for exemption calculation,Datele de închiriat pentru casa cerute pentru calcularea scutirii,
+House rented dates should be atleast 15 days apart,Căminul de închiriat al casei trebuie să fie la cel puțin 15 zile,
+How Pricing Rule is applied?,Cum se aplică regula pret?,
+Hub Category,Categorie Hub,
+Hub Sync ID,Hub ID de sincronizare,
+Human Resource,Resurse umane,
+Human Resources,Resurse umane,
+IFSC Code,Codul IFSC,
+IGST Amount,Suma IGST,
+IP Address,Adresa IP,
+ITC Available (whether in full op part),ITC Disponibil (fie în opțiune integrală),
+ITC Reversed,ITC inversat,
+Identifying Decision Makers,Identificarea factorilor de decizie,
+"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)","Dacă este bifată opțiunea Auto Opt In, clienții vor fi conectați automat la programul de loialitate respectiv (la salvare)",
+"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 selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Dacă regula de preț este selectată pentru &quot;Rate&quot;, va suprascrie lista de prețuri. Tarifarea tarifului Rata de rată este rata finală, deci nu trebuie să aplicați nici o reducere suplimentară. Prin urmare, în tranzacții cum ar fi Comandă de Vânzare, Comandă de Achiziție etc, va fi extrasă în câmpul &quot;Rată&quot;, mai degrabă decât în câmpul &quot;Rata Prețurilor&quot;.",
+"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 două sau mai multe reguli de stabilire a prețurilor sunt găsite bazează pe condițiile de mai sus, se aplică prioritate. Prioritatea este un număr între 0 și 20 în timp ce valoarea implicită este zero (gol). Numărul mai mare înseamnă că va avea prioritate în cazul în care există mai multe norme de stabilire a prețurilor, cu aceleași condiții.",
+"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.","Dacă expiră nelimitat pentru Punctele de loialitate, păstrați Durata de expirare goală sau 0.",
+"If you have any questions, please get back to us.","Dacă aveți întrebări, vă rugăm să ne întoarcem la noi.",
+Ignore Existing Ordered Qty,Ignorați cantitatea comandată existentă,
+Image,Imagine,
+Image View,Imagine Vizualizare,
+Import Data,Importați date,
+Import Day Book Data,Importați datele cărții de zi,
+Import Log,Import Conectare,
+Import Master Data,Importați datele de bază,
+Import in Bulk,Importare în masă,
+Import of goods,Importul de bunuri,
+Import of services,Importul serviciilor,
+Importing Items and UOMs,Importarea de articole și UOM-uri,
+Importing Parties and Addresses,Importarea părților și adreselor,
+In Maintenance,În Mentenanță,
+In Production,In productie,
+In Qty,În Cantitate,
+In Stock Qty,În stoc Cantitate,
+In Stock: ,In stoc:,
+In Value,În valoare,
+"In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent","În cazul unui program cu mai multe niveluri, Clienții vor fi automat alocați nivelului respectiv în funcție de cheltuielile efectuate",
+Inactive,Inactiv,
+Incentives,stimulente,
+Include Default Book Entries,Includeți intrări implicite în cărți,
+Include Exploded Items,Includeți articole explodate,
+Include POS Transactions,Includeți tranzacțiile POS,
+Include UOM,Includeți UOM,
+Included in Gross Profit,Inclus în Profitul brut,
+Income,Venit,
+Income Account,Contul de venit,
+Income Tax,Impozit pe venit,
+Incoming,Primite,
+Incoming Rate,Rate 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.,
+Increment cannot be 0,Creștere nu poate fi 0,
+Increment for Attribute {0} cannot be 0,Creștere pentru Atribut {0} nu poate fi 0,
+Indirect Expenses,Cheltuieli indirecte,
+Indirect Income,Venituri indirecte,
+Individual,Individual,
+Ineligible ITC,ITC neeligibil,
+Initiated,Iniţiat,
+Inpatient Record,Înregistrări de pacienți,
+Insert,Introduceți,
+Installation Note,Instalare Notă,
+Installation Note {0} has already been submitted,Instalarea Nota {0} a fost deja prezentat,
+Installation date cannot be before delivery date for Item {0},Data de instalare nu poate fi înainte de data de livrare pentru postul {0},
+Installing presets,Instalarea presetărilor,
+Institute Abbreviation,Institutul Abreviere,
+Institute Name,Numele Institutului,
+Instructor,Instructor,
+Insufficient Stock,Stoc insuficient,
+Insurance Start date should be less than Insurance End date,Asigurare Data de pornire ar trebui să fie mai mică de asigurare Data terminării,
+Integrated Tax,Impozit integrat,
+Inter-State Supplies,Consumabile inter-statale,
+Interest Amount,Suma Dobânda,
+Interests,interese,
+Intern,interna,
+Internet Publishing,Editura Internet,
+Intra-State Supplies,Furnizori intra-statale,
+Introduction,Introducere,
+Invalid Attribute,Atribut nevalid,
+Invalid Blanket Order for the selected Customer and Item,Comanda nevalabilă pentru client și element selectat,
+Invalid Company for Inter Company Transaction.,Companie nevalidă pentru tranzacția inter companie.,
+Invalid GSTIN! A GSTIN must have 15 characters.,GSTIN nevalid! Un GSTIN trebuie să aibă 15 caractere.,
+Invalid GSTIN! First 2 digits of GSTIN should match with State number {0}.,GSTIN nevalid! Primele 2 cifre ale GSTIN ar trebui să se potrivească cu numărul de stat {0}.,
+Invalid GSTIN! The input you've entered doesn't match the format of GSTIN.,GSTIN nevalid! Intrarea introdusă nu corespunde formatului GSTIN.,
+Invalid Posting Time,Ora nevalidă a postării,
+Invalid attribute {0} {1},atribut nevalid {0} {1},
+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.,
+Invalid reference {0} {1},Referință invalid {0} {1},
+Invalid {0},Invalid {0},
+Invalid {0} for Inter Company Transaction.,Nevalabil {0} pentru tranzacția între companii.,
+Invalid {0}: {1},Invalid {0}: {1},
+Inventory,Inventarierea,
+Investment Banking,Investment Banking,
+Investments,investiţii,
+Invoice,Factură,
+Invoice Created,Factura creată,
+Invoice Discounting,Reducerea facturilor,
+Invoice Patient Registration,Inregistrarea pacientului,
+Invoice Posting Date,Data Postare factură,
+Invoice Type,Tip Factura,
+Invoice already created for all billing hours,Factura deja creată pentru toate orele de facturare,
+Invoice can't be made for zero billing hour,Factura nu poate fi făcută pentru cantitate 0 ore facturabile,
+Invoice {0} no longer exists,Factura {0} nu mai există,
+Invoiced,facturată,
+Invoiced Amount,Sumă facturată,
+Invoices,Facturi,
+Invoices for Costumers.,Facturi pentru clienți.,
+Inward supplies from ISD,Consumabile interioare de la ISD,
+Inward supplies liable to reverse charge (other than 1 & 2 above),Livrări interne susceptibile de încărcare inversă (altele decât 1 și 2 de mai sus),
+Is Active,Este activ,
+Is Default,Este Implicit,
+Is Existing Asset,Este activ existent,
+Is Frozen,Este inghetat,
+Is Group,Is Group,
+Issue,Problema,
+Issue Material,Eliberarea Material,
+Issued,Emis,
+Issues,Probleme,
+It is needed to fetch Item Details.,Este nevoie să-i aducă Detalii despre articol.,
+Item,Obiect,
+Item 1,Postul 1,
+Item 2,Punctul 2,
+Item 3,Punctul 3,
+Item 4,Punctul 4,
+Item 5,Punctul 5,
+Item Cart,Cos,
+Item Code,Cod articol,
+Item Code cannot be changed for Serial No.,Cod articol nu pot fi schimbate pentru Serial No.,
+Item Code required at Row No {0},Cod Articol necesar la inregistrarea Nr. {0},
+Item Description,Descriere Articol,
+Item Group,Grup Articol,
+Item Group Tree,Ramificatie Grup Articole,
+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 Name,Numele articolului,
+Item Price added for {0} in Price List {1},Articol Preț adăugată pentru {0} în lista de prețuri {1},
+"Item Price appears multiple times based on Price List, Supplier/Customer, Currency, Item, UOM, Qty and Dates.","Elementul Preț apare de mai multe ori pe baza listei de prețuri, furnizor / client, valută, element, UOM, cantitate și date.",
+Item Price updated for {0} in Price List {1},Articol Preț actualizat pentru {0} în lista de prețuri {1},
+Item Row {0}: {1} {2} does not exist in above '{1}' table,Rândul {0}: {1} {2} nu există în tabelul de mai sus {1},
+Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Taxa Articol pentru inregistrarea {0} trebuie sa detina un cont de tip Fiscal sau De Venituri sau De Cheltuieli sau Taxabil,
+Item Template,Șablon de șablon,
+Item Variant Settings,Setări pentru variantele de articol,
+Item Variant {0} already exists with same attributes,Postul Varianta {0} există deja cu aceleași atribute,
+Item Variants,Variante Postul,
+Item Variants updated,Variante de articol actualizate,
+Item has variants.,Element are variante.,
+Item must be added using 'Get Items from Purchase Receipts' button,"Postul trebuie să fie adăugate folosind ""obține elemente din Cumpără Încasări"" buton",
+Item valuation rate is recalculated considering landed cost voucher amount,Rata de evaluare Articolul este recalculat în vedere aterizat sumă voucher de cost,
+Item variant {0} exists with same attributes,Postul varianta {0} există cu aceleași atribute,
+Item {0} does not exist,Articolul {0} nu există,
+Item {0} does not exist in the system or has expired,Articolul {0} nu există în sistem sau a expirat,
+Item {0} has already been returned,Articolul {0} a fost deja returnat,
+Item {0} has been disabled,Postul {0} a fost dezactivat,
+Item {0} has reached its end of life on {1},Articolul {0} a ajuns la sfârșitul cliclului sau de viață in {1},
+Item {0} ignored since it is not a stock item,"Element {0} ignorat, deoarece nu este un element de stoc",
+"Item {0} is a template, please select one of its variants","Postul {0} este un șablon, vă rugăm să selectați unul dintre variantele sale",
+Item {0} is cancelled,Articolul {0} este anulat,
+Item {0} is disabled,Postul {0} este dezactivat,
+Item {0} is not a serialized Item,Articolul {0} nu este un articol serializat,
+Item {0} is not a stock Item,Articolul{0} nu este un element de stoc,
+Item {0} is not active or end of life has been reached,Articolul {0} nu este activ sau sfarsitul ciclului sau de viata a fost atins,
+Item {0} is not setup for Serial Nos. Check Item master,Articolul {0} nu este configurat pentru Numerotare Seriala. Verificati Articolul Principal.,
+Item {0} is not setup for Serial Nos. Column must be blank,Articolul {0} nu este configurat pentru Numerotare Seriala. Coloana trebuie să fie vida,
+Item {0} must be a Fixed Asset Item,Postul {0} trebuie să fie un element activ fix,
+Item {0} must be a Sub-contracted Item,Articolul {0} trebuie să fie un Articol Sub-contractat,
+Item {0} must be a non-stock item,Postul {0} trebuie să fie un element de bază non-stoc,
+Item {0} must be a stock Item,Articolul {0} trebuie să fie un Articol de Stoc,
+Item {0} not found,Articolul {0} nu a fost găsit,
+Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Postul {0} nu a fost găsit în &quot;Materii prime furnizate&quot; masă în Comandă {1},
+Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Postul {0}: Cantitate comandat {1} nu poate fi mai mică de cantitate minimă de comandă {2} (definită la punctul).,
+Item: {0} does not exist in the system,Postul: {0} nu există în sistemul,
+Items,Articole,
+Items Filter,Filtrarea elementelor,
+Items and Pricing,Articole și Prețuri,
+Items for Raw Material Request,Articole pentru cererea de materii prime,
+Job Card,Carte de muncă,
+Job Description,Descrierea postului,
+Job Offer,Ofertă de muncă,
+Job card {0} created,Cartea de activitate {0} a fost creată,
+Jobs,Posturi,
+Join,A adera,
+Journal Entries {0} are un-linked,Intrările Jurnal {0} sunt ne-legate,
+Journal Entry,Intrare în jurnal,
+Journal Entry {0} does not have account {1} or already matched against other voucher,Jurnal de intrare {0} nu are cont {1} sau deja comparate cu alte voucher,
+Kanban Board,Consiliul de Kanban,
+Key Reports,Rapoarte cheie,
+LMS Activity,Activitate LMS,
+Lab Test,Test de laborator,
+Lab Test Report,Raport de testare în laborator,
+Lab Test Sample,Test de laborator,
+Lab Test Template,Lab Test Template,
+Lab Test UOM,Laboratorul de testare UOM,
+Lab Tests and Vital Signs,Teste de laborator și semne vitale,
+Lab result datetime cannot be before testing datetime,Rezultatul datetimei de laborator nu poate fi înainte de data testării,
+Lab testing datetime cannot be before collection datetime,Timpul de testare al laboratorului nu poate fi înainte de data de colectare,
+Label,Eticheta,
+Laboratory,Laborator,
+Language Name,Nume limbă,
+Large,Mare,
+Last Communication,Ultima comunicare,
+Last Communication Date,Ultima comunicare,
+Last Name,Nume,
+Last Order Amount,Ultima cantitate,
+Last Order Date,Ultima comandă Data,
+Last Purchase Price,Ultima valoare de cumpărare,
+Last Purchase Rate,Ultima Rate de Cumparare,
+Latest,Ultimul,
+Latest price updated in all BOMs,Ultimul preț actualizat în toate BOM-urile,
+Lead,Pistă,
+Lead Count,Număr Pistă,
+Lead Owner,Proprietar Pistă,
+Lead Owner cannot be same as the Lead,Plumb Proprietarul nu poate fi aceeași ca de plumb,
+Lead Time Days,Timpul in Zile Conducere,
+Lead to Quotation,Pistă către Ofertă,
+"Leads help you get business, add all your contacts and more as your leads","Oportunitati de afaceri ajuta să obțineți, adăugați toate contactele și mai mult ca dvs. conduce",
+Learn,Învăța,
+Leave Approval Notification,Lăsați notificarea de aprobare,
+Leave Blocked,Concediu Blocat,
+Leave Encashment,Lasă încasări,
+Leave Management,Lasă managementul,
+Leave Status Notification,Lăsați notificarea de stare,
+Leave Type,Tip Concediu,
+Leave Type is madatory,Tipul de plecare este madatoriu,
+Leave Type {0} cannot be allocated since it is leave without pay,"Lasă un {0} Tipul nu poate fi alocată, deoarece este în concediu fără plată",
+Leave Type {0} cannot be carry-forwarded,Lasă Tipul {0} nu poate fi transporta-transmise,
+Leave Type {0} is not encashable,Tipul de plecare {0} nu este încasat,
+Leave Without Pay,Concediu Fără Plată,
+Leave and Attendance,Plece și prezență,
+Leave application {0} already exists against the student {1},Lăsați aplicația {0} să existe deja împotriva elevului {1},
+"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Concediu nu poate fi repartizat înainte {0}, ca echilibru concediu a fost deja carry transmise în viitor înregistrarea alocare concediu {1}",
+"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Lasă nu poate fi aplicat / anulata pana la {0}, ca echilibru concediu a fost deja carry transmise în viitor înregistrarea alocare concediu {1}",
+Leave of type {0} cannot be longer than {1},Concediul de tip {0} nu poate dura mai mare de {1},
+Leaves,Frunze,
+Leaves Allocated Successfully for {0},Concedii alocate cu succes pentru {0},
+Leaves has been granted sucessfully,Frunzele au fost acordate cu succes,
+Leaves must be allocated in multiples of 0.5,"Concediile trebuie să fie alocate în multipli de 0.5""",
+Leaves per Year,Frunze pe an,
+Ledger,Registru Contabil,
+Legal,Juridic,
+Legal Expenses,Cheltuieli Juridice,
+Letter Head,Antet Scrisoare,
+Letter Heads for print templates.,Antete de Scrisoare de Sabloane de Imprimare.,
+Level,Nivel,
+Liability,Răspundere,
+License,Licență,
+Lifecycle,Ciclu de viață,
+Limit,Limită,
+Limit Crossed,limita Traversat,
+Link to Material Request,Link la solicitarea materialului,
+List of all share transactions,Lista tuturor tranzacțiilor cu acțiuni,
+List of available Shareholders with folio numbers,Lista Acționarilor disponibili cu numere folio,
+Loading Payment System,Încărcarea sistemului de plată,
+Loan,Împrumut,
+Loan Amount cannot exceed Maximum Loan Amount of {0},Suma creditului nu poate depăși valoarea maximă a împrumutului de {0},
+Loan Application,Cerere de împrumut,
+Loan Management,Managementul împrumuturilor,
+Loan Repayment,Rambursare a creditului,
+Loan Start Date and Loan Period are mandatory to save the Invoice Discounting,Data de început a împrumutului și perioada de împrumut sunt obligatorii pentru a salva reducerea facturilor,
+Loans (Liabilities),Imprumuturi (Raspunderi),
+Loans and Advances (Assets),Împrumuturi și avansuri (active),
+Local,Local,
+Log,Buturuga,
+Logs for maintaining sms delivery status,Busteni pentru menținerea statutului de livrare sms,
+Lost,Pierdut,
+Lost Reasons,Motivele pierdute,
+Low,Scăzut,
+Low Sensitivity,Sensibilitate scăzută,
+Lower Income,Micsoreaza Venit,
+Loyalty Amount,Suma de loialitate,
+Loyalty Point Entry,Punct de loialitate,
+Loyalty Points,Puncte de loialitate,
+"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Punctele de loialitate vor fi calculate din suma cheltuită (prin factura de vânzare), pe baza factorului de colectare menționat.",
+Loyalty Points: {0},Puncte de fidelitate: {0},
+Loyalty Program,Program de fidelizare,
+Main,Principal,
+Maintenance,Mentenanţă,
+Maintenance Log,Jurnal Mentenanță,
+Maintenance Manager,Manager Mentenanță,
+Maintenance Schedule,Program Mentenanță,
+Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Programul de Mentenanta nu este generat pentru toate articolele. Vă rugăm să faceți clic pe 'Generare Program',
+Maintenance Schedule {0} exists against {1},Planul de Mentenanță {0} există împotriva {1},
+Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Programul de Mentenanță{0} trebuie anulat înainte de a anula această Comandă de Vânzări,
+Maintenance Status has to be Cancelled or Completed to Submit,Starea de întreținere trebuie anulată sau finalizată pentru a fi trimisă,
+Maintenance User,Întreținere utilizator,
+Maintenance Visit,Vizită Mentenanță,
+Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Vizita de Mentenanță {0} trebuie să fie anulată înainte de a anula această Comandă de Vânzări,
+Maintenance start date can not be before delivery date for Serial No {0},Data de Incepere a Mentenantei nu poate fi anterioara datei de livrare aferent de Nr. de Serie {0},
+Make,Realizare,
+Make Payment,Plateste,
+Make project from a template.,Realizați proiectul dintr-un șablon.,
+Making Stock Entries,Efectuarea de stoc Entries,
+Male,Masculin,
+Manage Customer Group Tree.,Gestioneaza Ramificatiile de Group a Clientului.,
+Manage Sales Partners.,Gestionează Parteneri Vânzări,
+Manage Sales Person Tree.,Gestioneaza Ramificatiile Persoanei responsabila cu Vanzarile,
+Manage Territory Tree.,Gestioneaza Ramificatiile Teritoriule.,
+Manage your orders,Gestionează Comenzi,
+Management,Management,
+Manager,Manager,
+Managing Projects,Managementul Proiectelor,
+Managing Subcontracting,Gestionarea Subcontracte,
+Mandatory,Obligatoriu,
+Mandatory field - Academic Year,Domeniu obligatoriu - An universitar,
+Mandatory field - Get Students From,Domeniu obligatoriu - Obțineți elevii de la,
+Mandatory field - Program,Câmp obligatoriu - Program,
+Manufacture,Fabricare,
+Manufacturer,Producător,
+Manufacturer Part Number,Numarul de piesa,
+Manufacturing,Producţie,
+Manufacturing Quantity is mandatory,Cantitatea de fabricație este obligatorie,
+Mapping,Cartografierea,
+Mapping Type,Tipul de tipărire,
+Mark Absent,Mark Absent,
+Mark Attendance,Marchează prezența,
+Mark Half Day,Mark jumatate de zi,
+Mark Present,Mark Prezent,
+Marketing,Marketing,
+Marketing Expenses,Cheltuieli de marketing,
+Marketplace,Piata de desfacere,
+Marketplace Error,Eroare de pe piață,
+Masters,Masterat,
+Match Payments with Invoices,Plățile se potrivesc cu facturi,
+Match non-linked Invoices and Payments.,Potrivesc Facturi non-legate și plăți.,
+Material,Material,
+Material Consumption,Consumul de materiale,
+Material Consumption is not set in Manufacturing Settings.,Consumul de materiale nu este setat în Setări de fabricare.,
+Material Receipt,Primirea de material,
+Material Request,Cerere de material,
+Material Request Date,Cerere de material Data,
+Material Request No,Cerere de material Nu,
+"Material Request not created, as quantity for Raw Materials already available.","Cerere de material nefiind creată, ca cantitate pentru materiile prime deja disponibile.",
+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 to Purchase Order,Cerere de material de cumpărare Ordine,
+Material Request {0} is cancelled or stopped,Cerere de material {0} este anulată sau oprită,
+Material Request {0} submitted.,Cerere de materiale {0} trimisă.,
+Material Transfer,Transfer de material,
+Material Transferred,Material transferat,
+Material to Supplier,Material de Furnizor,
+Max Exemption Amount cannot be greater than maximum exemption amount {0} of Tax Exemption Category {1},Suma maximă de scutire nu poate fi mai mare decât valoarea scutirii maxime {0} din categoria scutirii de impozite {1},
+Max benefits should be greater than zero to dispense benefits,Beneficiile maxime ar trebui să fie mai mari decât zero pentru a renunța la beneficii,
+Max discount allowed for item: {0} is {1}%,Discount maxim permis pentru articol: {0} este {1}%,
+Max: {0},Max: {0},
+Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Probele maxime - {0} pot fi păstrate pentru lotul {1} și articolul {2}.,
+Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Probele maxime - {0} au fost deja reținute pentru lotul {1} și articolul {2} din lotul {3}.,
+Maximum amount eligible for the component {0} exceeds {1},Suma maximă eligibilă pentru componenta {0} depășește {1},
+Maximum benefit amount of component {0} exceeds {1},Suma maximă de beneficii a componentei {0} depășește {1},
+Maximum benefit amount of employee {0} exceeds {1},Suma maximă a beneficiilor angajatului {0} depășește {1},
+Maximum discount for Item {0} is {1}%,Reducerea maximă pentru articolul {0} este {1}%,
+Maximum leave allowed in the leave type {0} is {1},Permisul maxim permis în tipul de concediu {0} este {1},
+Medical,Medical,
+Medical Code,Codul medical,
+Medical Code Standard,Codul medical standard,
+Medical Department,Departamentul medical,
+Medical Record,Fișă medicală,
+Medium,Medie,
+Meeting,Întâlnire,
+Member Activity,Activitatea membrilor,
+Member ID,Membru ID,
+Member Name,Numele membrului,
+Member information.,Informații despre membri.,
+Membership,apartenență,
+Membership Details,Detalii de membru,
+Membership ID,ID-ul de membru,
+Membership Type,Tipul de membru,
+Memebership Details,Detalii de membru,
+Memebership Type Details,Detalii despre tipul de membru,
+Merge,contopi,
+Merge Account,Îmbinare cont,
+Merge with Existing Account,Mergeți cu contul existent,
+"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Fuziune este posibilă numai în cazul în care următoarele proprietăți sunt aceleași în ambele registre. Este Group, Root Type, Company",
+Message Examples,Exemple de mesaje,
+Message Sent,Mesajul a fost trimis,
+Method,Metoda,
+Middle Income,Venituri medii,
+Middle Name,Al doilea nume,
+Middle Name (Optional),Al Doilea Nume (Opțional),
+Min Amt can not be greater than Max Amt,Min Amt nu poate fi mai mare decât Max Amt,
+Min Qty can not be greater than Max Qty,Min Cantitate nu poate fi mai mare decât Max Cantitate,
+Minimum Lead Age (Days),Vârsta minimă de plumb (zile),
+Miscellaneous Expenses,Cheltuieli diverse,
+Missing Currency Exchange Rates for {0},Lipsesc cursuri de schimb valutar pentru {0},
+Missing email template for dispatch. Please set one in Delivery Settings.,Șablonul de e-mail lipsă pentru expediere. Alegeți unul din Setările de livrare.,
+"Missing value for Password, API Key or Shopify URL","Valoare lipsă pentru parola, cheia API sau adresa URL pentru cumpărături",
+Mode of Payment,Modul de plată,
+Mode of Payments,Modul de plată,
+Mode of Transport,Mijloc de transport,
+Mode of Transportation,Mijloc de transport,
+Mode of payment is required to make a payment,Modul de plată este necesară pentru a efectua o plată,
+Model,Model,
+Moderate Sensitivity,Sensibilitate moderată,
+Monday,Luni,
+Monthly,Lunar,
+Monthly Distribution,Distributie lunar,
+Monthly Repayment Amount cannot be greater than Loan Amount,Rambursarea lunară Suma nu poate fi mai mare decât Suma creditului,
+More,Mai mult,
+More Information,Mai multe informatii,
+More than one selection for {0} not allowed,Nu sunt permise mai multe selecții pentru {0},
+More...,Mai Mult...,
+Motion Picture & Video,Motion Picture & Video,
+Move,Mutare,
+Move Item,Postul mutare,
+Multi Currency,Multi valutar,
+Multiple Item prices.,Mai multe prețuri element.,
+Multiple Loyalty Program found for the Customer. Please select manually.,Programul de loialitate multiplă găsit pentru client. Selectați manual.,
+"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Reguli de preturi multiple există cu aceleași criterii, vă rugăm să rezolve conflictul prin atribuirea de prioritate. Reguli de preț: {0}",
+Multiple Variants,Variante multiple,
+Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,ani fiscali multiple exista in data de {0}. Vă rugăm să setați companie în anul fiscal,
+Music,Muzica,
+My Account,Contul Meu,
+Name error: {0},Numele de eroare: {0},
+Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Numele de cont nou. Notă: Vă rugăm să nu creați conturi pentru clienți și furnizori,
+Name or Email is mandatory,Nume sau E-mail este obligatorie,
+Nature Of Supplies,Natura aprovizionării,
+Navigating,Navigarea,
+Needs Analysis,Analiza nevoilor,
+Negative Quantity is not allowed,Nu este permisă cantitate negativă,
+Negative Valuation Rate is not allowed,Negativ Rata de evaluare nu este permis,
+Negotiation/Review,Negocierea / revizuire,
+Net Asset value as on,Valoarea activelor nete pe,
+Net Cash from Financing,Numerar net din Finantare,
+Net Cash from Investing,Numerar net din investiții,
+Net Cash from Operations,Numerar net din operațiuni,
+Net Change in Accounts Payable,Schimbarea net în conturi de plătit,
+Net Change in Accounts Receivable,Schimbarea net în conturile de creanțe,
+Net Change in Cash,Schimbarea net în numerar,
+Net Change in Equity,Schimbarea net în capitaluri proprii,
+Net Change in Fixed Asset,Schimbarea net în active fixe,
+Net Change in Inventory,Schimbarea net în inventar,
+Net ITC Available(A) - (B),ITC net disponibil (A) - (B),
+Net Pay,Plată netă,
+Net Pay cannot be less than 0,Plata netă nu poate fi mai mică decât 0,
+Net Profit,Profit net,
+Net Salary Amount,Valoarea netă a salariului,
+Net Total,Total net,
+Net pay cannot be negative,Salariul net nu poate fi negativ,
+New Account Name,Nume nou cont,
+New Address,Adresa noua,
+New BOM,Nou BOM,
+New Batch ID (Optional),ID-ul lotului nou (opțional),
+New Batch Qty,Numărul nou de loturi,
+New Company,Companie nouă,
+New Cost Center Name,Numele noului centru de cost,
+New Customer Revenue,Noi surse de venit pentru clienți,
+New Customers,clienti noi,
+New Department,Departamentul nou,
+New Employee,Angajat nou,
+New Location,Locație nouă,
+New Quality Procedure,Noua procedură de calitate,
+New Sales Invoice,Adauga factură de vânzări,
+New Sales Person Name,Nume nou Agent 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 Warehouse Name,Nume nou depozit,
+New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Noua limită de credit este mai mică decât valoarea curentă restante pentru client. Limita de credit trebuie să fie atleast {0},
+New task,Sarcina noua,
+New {0} pricing rules are created,Sunt create noi {0} reguli de preț,
+Newsletters,Buletine,
+Newspaper Publishers,Editorii de ziare,
+Next,Următor,
+Next Contact By cannot be same as the Lead Email Address,Următoarea Contact Prin faptul că nu poate fi aceeași cu adresa de e-mail Plumb,
+Next Contact Date cannot be in the past,În continuare Contact Data nu poate fi în trecut,
+Next Steps,Pasii urmatori,
+No Action,Fara actiune,
+No Customers yet!,Nu există clienți încă!,
+No Data,No Data,
+No Delivery Note selected for Customer {},Nu este selectată nicio notificare de livrare pentru client {},
+No Employee Found,Nu a fost găsit angajat,
+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 available for transfer,Nu există elemente disponibile pentru transfer,
+No Items selected for transfer,Nu există elemente selectate pentru transfer,
+No Items to pack,Nu sunt produse în ambalaj,
+No Items with Bill of Materials to Manufacture,Nu există niciun articol cu Lista de materiale pentru fabricarea,
+No Items with Bill of Materials.,Nu există articole cu Bill of Materials.,
+No Permission,Nici o permisiune,
+No Remarks,Nu Observații,
+No Result to submit,Niciun rezultat nu trebuie trimis,
+No Salary Structure assigned for Employee {0} on given date {1},Nu există structură salarială atribuită pentru angajat {0} la data dată {1},
+No Staffing Plans found for this Designation,Nu au fost găsite planuri de personal pentru această desemnare,
+No Student Groups created.,Nu există grupuri create de studenți.,
+No Students in,Nu există studenți în,
+No Tax Withholding data found for the current Fiscal Year.,Nu au fost găsite date privind reținerea fiscală pentru anul fiscal curent.,
+No Work Orders created,Nu au fost create comenzi de lucru,
+No accounting entries for the following warehouses,Nici o intrare contabile pentru următoarele depozite,
+No active or default Salary Structure found for employee {0} for the given dates,Nr Structură activă sau Salariul implicit găsite pentru angajat al {0} pentru datele indicate,
+No contacts with email IDs found.,Nu au fost găsite contacte cu ID-urile de e-mail.,
+No data for this period,Nu există date pentru această perioadă,
+No description given,Nici o descriere dat,
+No employees for the mentioned criteria,Nu există angajați pentru criteriile menționate,
+No gain or loss in the exchange rate,Nu există cheltuieli sau venituri din diferente ale cursului de schimb,
+No items listed,Nu sunt enumerate elemente,
+No items to be received are overdue,Nu sunt întârziate niciun element de primit,
+No material request created,Nu a fost creată nicio solicitare materială,
+No more updates,Nu există mai multe actualizări,
+No of Interactions,Nr de interacțiuni,
+No of Shares,Numărul de acțiuni,
+No pending Material Requests found to link for the given items.,Nu au fost găsite solicitări de material în așteptare pentru link-ul pentru elementele date.,
+No products found,Nu au fost găsite produse,
+No products found.,Nu găsiți produse.,
+No record found,Nu s-au găsit înregistrări,
+No records found in the Invoice table,Nu sunt găsite inregistrari în tabelul de facturi înregistrate,
+No records found in the Payment table,Nu sunt găsite în tabelul de plăți înregistrări,
+No replies from,Nu există răspunsuri de la,
+No salary slip found to submit for the above selected criteria OR salary slip already submitted,Nu s-a găsit nicio corespondență salarială pentru criteriile de mai sus sau salariul deja trimis,
+No tasks,Nu există nicio sarcină,
+No time sheets,Nu există nicio foaie de timp,
+No values,Fără valori,
+No {0} found for Inter Company Transactions.,Nu a fost găsit {0} pentru tranzacțiile Intercompanie.,
+Non GST Inward Supplies,Consumabile interioare non-GST,
+Non Profit,Non-Profit,
+Non Profit (beta),Nonprofit (beta),
+Non-GST outward supplies,Oferte externe non-GST,
+Non-Group to Group,Non-Grup la Grup,
+None,Nici unul,
+None of the items have any change in quantity or value.,Nici unul din elementele au nici o schimbare în cantitate sau de valoare.,
+Nos,nos,
+Not Available,Indisponibil,
+Not Marked,nemarcate,
+Not Paid and Not Delivered,Nu sunt plătite și nu sunt livrate,
+Not Permitted,Nu este permisă,
+Not Started,Neînceput,
+Not active,Nu este activ,
+Not allow to set alternative item for the item {0},Nu permiteți setarea unui element alternativ pentru articolul {0},
+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 {0} blocat,
+Not authroized since {0} exceeds limits,Nu authroized din {0} depășește limitele,
+Not permitted for {0},Nu este permisă {0},
+"Not permitted, configure Lab Test Template as required","Nu este permisă, configurați Șablon de testare Lab așa cum este necesar",
+Not permitted. Please disable the Service Unit Type,Nu sunt acceptate. Dezactivați tipul unității de serviciu,
+Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Notă: Datorită / Reference Data depășește de companie zile de credit client de {0} zi (le),
+Note: Item {0} entered multiple times,Notă: Articolul {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,
+Nothing is included in gross,Nimic nu este inclus în brut,
+Nothing more to show.,Nimic mai mult pentru a arăta.,
+Nothing to change,Nimic de schimbat,
+Notice Period,Perioada de preaviz,
+Notify Customers via Email,Notificați clienții prin e-mail,
+Number,Număr,
+Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Numărul de Deprecieri Booked nu poate fi mai mare decât Număr total de Deprecieri,
+Number of Interaction,Numărul interacțiunii,
+Number of Order,Numărul de comandă,
+"Number of new Account, it will be included in the account name as a prefix","Numărul de cont nou, acesta va fi inclus în numele contului ca prefix",
+"Number of new Cost Center, it will be included in the cost center name as a prefix","Numărul noului Centru de cost, acesta va fi inclus în prefixul centrului de costuri",
+Number of root accounts cannot be less than 4,Numărul de conturi root nu poate fi mai mic de 4,
+Odometer,Contorul de kilometraj,
+Office Equipments,Echipamente de birou,
+Office Maintenance Expenses,Cheltuieli Mentenanță Birou,
+Office Rent,Birou inchiriat,
+On Hold,In asteptare,
+On Net Total,Pe Net Total,
+One customer can be part of only single Loyalty Program.,Un client poate face parte dintr-un singur program de loialitate.,
+Online Auctions,Licitatii online,
+Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Lăsați numai aplicațiile cu statut „Aprobat“ și „Respins“ pot fi depuse,
+"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",În tabelul de mai jos va fi selectat numai Solicitantul studenților cu statutul &quot;Aprobat&quot;.,
+Only users with {0} role can register on Marketplace,Numai utilizatorii cu rolul {0} se pot înregistra pe Marketplace,
+Open BOM {0},Deschideți BOM {0},
+Open Item {0},Deschis Postul {0},
+Open Notifications,Notificări deschise,
+Open Orders,Comenzi deschise,
+Open a new ticket,Deschideți un nou bilet,
+Opening,Deschidere,
+Opening (Cr),Deschidere (Cr),
+Opening (Dr),Deschidere (Dr),
+Opening Accounting Balance,Sold Contabilitate,
+Opening Accumulated Depreciation,Deschidere Amortizarea Acumulate,
+Opening Accumulated Depreciation must be less than equal to {0},Amortizarea de deschidere trebuie să fie mai mică Acumulate decât egală cu {0},
+Opening Balance,Soldul de deschidere,
+Opening Balance Equity,Sold Equity,
+Opening Date and Closing Date should be within same Fiscal Year,Deschiderea și data inchiderii ar trebui să fie în același an fiscal,
+Opening Date should be before Closing Date,"Deschiderea Data ar trebui să fie, înainte de Data inchiderii",
+Opening Entry Journal,Deschiderea Jurnalului de intrare,
+Opening Invoice Creation Tool,Deschiderea Instrumentului de creare a facturilor,
+Opening Invoice Item,Deschidere element factură,
+Opening Invoices,Deschiderea facturilor,
+Opening Invoices Summary,Sumar de deschidere a facturilor,
+Opening Qty,Deschiderea Cantitate,
+Opening Stock,deschidere stoc,
+Opening Stock Balance,Sold Stock,
+Opening Value,Valoarea de deschidere,
+Opening {0} Invoice created,Deschidere {0} Factură creată,
+Operation,Operație,
+Operation Time must be greater than 0 for Operation {0},Funcționarea timp trebuie să fie mai mare decât 0 pentru funcționare {0},
+"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Operațiunea {0} mai mult decât orice ore de lucru disponibile în stație de lucru {1}, descompun operațiunea în mai multe operațiuni",
+Operations,Operatii,
+Operations cannot be left blank,Operații nu poate fi lăsat necompletat,
+Opp Count,Opp Count,
+Opp/Lead %,Opp / Plumb%,
+Opportunities,Oportunități,
+Opportunities by lead source,Oportunități după sursă pistă,
+Opportunity,Oportunitate,
+Opportunity Amount,Oportunitate Sumă,
+Optional Holiday List not set for leave period {0},Lista de vacanță opțională nu este setată pentru perioada de concediu {0},
+"Optional. Sets company's default currency, if not specified.","Opțional. Setează implicit moneda companiei, în cazul în care nu este specificat.",
+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.,
+Options,Optiuni,
+Order Count,Numărătoarea comenzilor,
+Order Entry,Intrare comandă,
+Order Value,Valoarea comenzii,
+Order rescheduled for sync,Ordonată reprogramată pentru sincronizare,
+Order/Quot %,Ordine / Cotare%,
+Ordered,Ordonat,
+Ordered Qty,Ordonat Cantitate,
+"Ordered Qty: Quantity ordered for purchase, but not received.","Comandat Cantitate: Cantitatea comandat pentru cumpărare, dar nu a primit.",
+Orders,Comenzi,
+Orders released for production.,Comenzi lansat pentru producție.,
+Organization,Organizare,
+Organization Name,Numele Organizatiei,
+Other,Altul,
+Other Reports,Alte rapoarte,
+"Other outward supplies(Nil rated,Exempted)","Alte consumabile exterioare (Nil evaluat, scutit)",
+Others,Altel,
+Out Qty,Out Cantitate,
+Out Value,Valoarea afară,
+Out of Order,Scos din uz,
+Outgoing,Trimise,
+Outstanding,remarcabil,
+Outstanding Amount,Remarcabil Suma,
+Outstanding Amt,Impresionant Amt,
+Outstanding Cheques and Deposits to clear,Cecuri restante și pentru a șterge Depozite,
+Outstanding for {0} cannot be less than zero ({1}),Restante pentru {0} nu poate fi mai mică decât zero ({1}),
+Outward taxable supplies(zero rated),Livrări impozabile externe (zero),
+Overdue,întârziat,
+Overlap in scoring between {0} and {1},Suprapunerea punctajului între {0} și {1},
+Overlapping conditions found between:,Condiții se suprapun găsite între:,
+Owner,Proprietar,
+PAN,TIGAIE,
+POS,POS,
+POS Profile,POS Profil,
+POS Profile is required to use Point-of-Sale,Profilul POS este necesar pentru a utiliza Punctul de vânzare,
+POS Profile required to make POS Entry,POS Profil necesare pentru a face POS intrare,
+POS Settings,Setări POS,
+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 Slip,Slip de ambalare,
+Packing Slip(s) cancelled,Slip de ambalare (e) anulate,
+Paid,Plătit,
+Paid Amount,Suma plătită,
+Paid Amount cannot be greater than total negative outstanding amount {0},Suma plătită nu poate fi mai mare decât suma totală negativă restante {0},
+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,
+Paid and Not Delivered,Plătite și nu sunt livrate,
+Parameter,Parametru,
+Parent Item {0} must not be a Stock Item,Postul părinte {0} nu trebuie să fie un articol stoc,
+Parents Teacher Meeting Attendance,Conferința părinților la conferința părintească,
+Part-time,Part-time,
+Partially Depreciated,parțial Depreciata,
+Partially Received,Parțial primite,
+Party,Partener,
+Party Name,Nume partid,
+Party Type,Tip de partid,
+Party Type and Party is mandatory for {0} account,Tipul partidului și partidul este obligatoriu pentru contul {0},
+Party Type is mandatory,Tipul de partid este obligatorie,
+Party is mandatory,Party este obligatorie,
+Password,Parolă,
+Password policy for Salary Slips is not set,Politica de parolă pentru Salarii Slips nu este setată,
+Past Due Date,Data trecută,
+Patient,Rabdator,
+Patient Appointment,Numirea pacientului,
+Patient Encounter,Întâlnirea cu pacienții,
+Patient not found,Pacientul nu a fost găsit,
+Pay Remaining,Plătiți rămase,
+Pay {0} {1},Plătește {0} {1},
+Payable,plătibil,
+Payable Account,Contul furnizori,
+Payable Amount,Sumă plătibilă,
+Payment,Plată,
+Payment Cancelled. Please check your GoCardless Account for more details,Plata anulată. Verificați contul GoCardless pentru mai multe detalii,
+Payment Confirmation,Confirmarea platii,
+Payment Date,Data de plată,
+Payment Days,Zile de plată,
+Payment Document,Documentul de plată,
+Payment Due Date,Data scadentă de plată,
+Payment Entries {0} are un-linked,Intrările de plată {0} sunt nesemnalate legate,
+Payment Entry,Intrare plăţi,
+Payment Entry already exists,Există deja intrare plată,
+Payment Entry has been modified after you pulled it. Please pull it again.,Plata intrare a fost modificat după ce-l tras. Vă rugăm să trage din nou.,
+Payment Entry is already created,Plata Intrarea este deja creat,
+Payment Failed. Please check your GoCardless Account for more details,Plata esuata. Verificați contul GoCardless pentru mai multe detalii,
+Payment Gateway,Gateway de plată,
+"Payment Gateway Account not created, please create one manually.","Plata Gateway Cont nu a fost creată, vă rugăm să creați manual unul.",
+Payment Gateway Name,Numele gateway-ului de plată,
+Payment Mode,Modul de plată,
+Payment Receipt Note,Plată Primirea Note,
+Payment Request,Cerere de plata,
+Payment Request for {0},Solicitare de plată pentru {0},
+Payment Tems,Tems de plată,
+Payment Term,Termen de plata,
+Payment Terms,Termeni de plată,
+Payment Terms Template,Formularul termenilor de plată,
+Payment Terms based on conditions,Termeni de plată în funcție de condiții,
+Payment Type,Tip de plată,
+"Payment Type must be one of Receive, Pay and Internal Transfer","Tipul de plată trebuie să fie unul dintre Primire, Pay și de transfer intern",
+Payment against {0} {1} cannot be greater than Outstanding Amount {2},Plata împotriva {0} {1} nu poate fi mai mare decât Impresionant Suma {2},
+Payment of {0} from {1} to {2},Plata pentru {0} de la {1} la {2},
+Payment request {0} created,Solicitarea de plată {0} a fost creată,
+Payments,Plăți,
+Payroll,stat de plată,
+Payroll Number,Număr de salarizare,
+Payroll Payable,Salarizare plateste,
+Payslip,fluturaș,
+Pending Activities,Activități în curs,
+Pending Amount,În așteptarea Suma,
+Pending Leaves,Frunze în așteptare,
+Pending Qty,Așteptare Cantitate,
+Pending Quantity,Cantitate în așteptare,
+Pending Review,Revizuirea în curs,
+Pending activities for today,Activități în așteptare pentru ziua de azi,
+Pension Funds,Fondurile de pensii,
+Percentage Allocation should be equal to 100%,Alocarea procent ar trebui să fie egală cu 100%,
+Perception Analysis,Analiza percepției,
+Period,Perioada,
+Period Closing Entry,Intrarea Perioada de închidere,
+Period Closing Voucher,Voucher perioadă de închidere,
+Periodicity,Periodicitate,
+Personal Details,Detalii personale,
+Pharmaceutical,Farmaceutic,
+Pharmaceuticals,Produse farmaceutice,
+Physician,Medic,
+Piecework,muncă în acord,
+Pincode,Parola așa,
+Place Of Supply (State/UT),Locul livrării (stat / UT),
+Place Order,Locul de comandă,
+Plan Name,Numele planului,
+Plan for maintenance visits.,Plan pentru vizite de mentenanță.,
+Planned Qty,Planificate Cantitate,
+"Planned Qty: Quantity, for which, Work Order has been raised, but is pending to be manufactured.","Cantitate planificată: cantitatea pentru care a fost ridicată comanda de lucru, dar este în curs de fabricare.",
+Planning,Planificare,
+Plants and Machineries,Plante și mașini,
+Please Set Supplier Group in Buying Settings.,Setați Grupul de furnizori în Setări de cumpărare.,
+Please add a Temporary Opening account in Chart of Accounts,Adăugați un cont de deschidere temporară în Planul de conturi,
+Please add the account to root level Company - ,Vă rugăm să adăugați contul la nivelul companiei la nivel root -,
+Please add the remaining benefits {0} to any of the existing component,Vă rugăm să adăugați beneficiile rămase {0} la oricare dintre componentele existente,
+Please check Multi Currency option to allow accounts with other currency,Vă rugăm să verificați Multi opțiune de valuta pentru a permite conturi cu altă valută,
+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 confirm once you have completed your training,Vă rugăm să confirmați după ce ați terminat pregătirea,
+Please create purchase receipt or purchase invoice for the item {0},Creați factura de cumpărare sau factura de achiziție pentru elementul {0},
+Please define grade for Threshold 0%,Vă rugăm să definiți gradul pentru pragul 0%,
+Please enable Applicable on Booking Actual Expenses,Activați aplicabil pentru cheltuielile curente de rezervare,
+Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,Activați aplicabil la comanda de aprovizionare și aplicabil cheltuielilor curente de rezervare,
+Please enable default incoming account before creating Daily Work Summary Group,Activați contul de intrare implicit înainte de a crea un grup zilnic de lucru,
+Please enable pop-ups,Vă rugăm să activați pop-up-uri,
+Please enter 'Is Subcontracted' as Yes or No,"Va rugam sa introduceti ""este subcontractată"" ca Da sau Nu",
+Please enter API Consumer Key,Introduceți cheia de consum API,
+Please enter API Consumer Secret,Introduceți secretul pentru clienți API,
+Please enter Account for Change Amount,Vă rugăm să introduceți cont pentru Schimbare Sumă,
+Please enter Approving Role or Approving User,Vă rugăm să introduceți Aprobarea Rolul sau aprobarea de utilizare,
+Please enter Cost Center,Va rugam sa introduceti Cost Center,
+Please enter Delivery Date,Introduceți data livrării,
+Please enter Employee Id of this sales person,Vă rugăm să introduceți ID-ul de angajat al acestei persoane de vânzări,
+Please enter Expense Account,Va rugam sa introduceti cont de cheltuieli,
+Please enter Item Code to get Batch Number,Vă rugăm să introduceți codul de articol pentru a obține numărul de lot,
+Please enter Item Code to get batch no,Va rugam sa introduceti codul articol pentru a obține lot nu,
+Please enter Item first,Va rugam sa introduceti Articol primul,
+Please enter Maintaince Details first,Va rugam sa introduceti maintaince detaliile prima,
+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 Preferred Contact Email,Vă rugăm să introduceți preferate Contact E-mail,
+Please enter Production Item first,Va rugam sa introduceti de producție Articol întâi,
+Please enter Purchase Receipt first,Va rugam sa introduceti Primirea achiziția,
+Please enter Receipt Document,Vă rugăm să introduceți Document Primirea,
+Please enter Reference date,Vă rugăm să introduceți data de referință,
+Please enter Repayment Periods,Vă rugăm să introduceți perioada de rambursare,
+Please enter Reqd by Date,Introduceți Reqd după dată,
+Please enter Woocommerce Server URL,Introduceți adresa URL a serverului Woocommerce,
+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 currency in Company Master,Va rugam sa introduceti moneda implicit în Compania de Master,
+Please enter message before sending,Vă rugăm să introduceți mesajul înainte de trimitere,
+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 repayment Amount,Vă rugăm să introduceți Suma de rambursare,
+Please enter valid Financial Year Start and End Dates,Va rugam sa introduceti valabil financiare Anul începe și a termina Perioada,
+Please enter valid email address,Introduceți adresa de e-mail validă,
+Please enter {0} first,Va rugam sa introduceti {0} primul,
+Please fill in all the details to generate Assessment Result.,Vă rugăm să completați toate detaliile pentru a genera rezultatul evaluării.,
+Please identify/create Account (Group) for type - {0},Vă rugăm să identificați / să creați un cont (grup) pentru tipul - {0},
+Please identify/create Account (Ledger) for type - {0},Vă rugăm să identificați / să creați un cont (contabil) pentru tipul - {0},
+Please login as another user to register on Marketplace,Conectați-vă ca alt utilizator pentru a vă înregistra pe Marketplace,
+Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,Vă rugăm să asigurați-vă că într-adevăr să ștergeți toate tranzacțiile pentru această companie. Datele dvs. de bază vor rămâne așa cum este. Această acțiune nu poate fi anulată.,
+Please mention Basic and HRA component in Company,Vă rugăm să menționați componentele de bază și HRA în cadrul companiei,
+Please mention Round Off Account in Company,Vă rugăm să menționați rotunji contul în companie,
+Please mention Round Off Cost Center in Company,Vă rugăm să menționați rotunji Center cost în companie,
+Please mention no of visits required,Vă rugăm să menționați nici de vizite necesare,
+Please mention the Lead Name in Lead {0},Menționați numele de plumb din plumb {0},
+Please pull items from Delivery Note,Vă rugăm să trage elemente de livrare Nota,
+Please register the SIREN number in the company information file,Înregistrați numărul SIREN în fișierul cu informații despre companie,
+Please remove this Invoice {0} from C-Form {1},Vă rugăm să eliminați acest factură {0} de la C-Form {1},
+Please save the patient first,Salvați mai întâi pacientul,
+Please save the report again to rebuild or update,Vă rugăm să salvați raportul din nou pentru a reconstrui sau actualiza,
+"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Vă rugăm să selectați suma alocată, de tip Factură și factură Numărul din atleast rând una",
+Please select Apply Discount On,Vă rugăm să selectați Aplicați Discount On,
+Please select BOM against item {0},Selectați BOM pentru elementul {0},
+Please select BOM for Item in Row {0},Vă rugăm să selectați BOM pentru postul în rândul {0},
+Please select BOM in BOM field for Item {0},Vă rugăm să selectați BOM BOM în domeniu pentru postul {0},
+Please select Category first,Vă rugăm să selectați categoria întâi,
+Please select Charge Type first,Vă rugăm să selectați tipul de taxă în primul rând,
+Please select Company,Vă rugăm să selectați Company,
+Please select Company and Designation,Selectați Companie și desemnare,
+Please select Company and Posting Date to getting entries,Selectați Company and Dateing date pentru a obține înregistrări,
+Please select Company first,Vă rugăm să selectați Company primul,
+Please select Completion Date for Completed Asset Maintenance Log,Selectați Data de încheiere pentru jurnalul de întreținere a activelor finalizat,
+Please select Completion Date for Completed Repair,Selectați Data de finalizare pentru Repararea finalizată,
+Please select Course,Selectați cursul,
+Please select Drug,Selectați Droguri,
+Please select Employee,Selectați Angajat,
+Please select Existing Company for creating Chart of Accounts,Vă rugăm să selectați Companie pentru crearea Existent Plan de conturi,
+Please select Healthcare Service,Selectați Serviciul de asistență medicală,
+"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle",Vă rugăm să selectați postul unde &quot;Este Piesa&quot; este &quot;nu&quot; și &quot;Este punctul de vânzare&quot; este &quot;da&quot; și nu este nici un alt produs Bundle,
+Please select Maintenance Status as Completed or remove Completion Date,Selectați Stare de întreținere ca Completat sau eliminați Data de finalizare,
+Please select Party Type first,Vă rugăm să selectați Party Type primul,
+Please select Patient,Selectați pacientul,
+Please select Patient to get Lab Tests,Selectați pacientul pentru a obține testele de laborator,
+Please select Posting Date before selecting Party,Vă rugăm să selectați Dată postare înainte de a selecta Parte,
+Please select Posting Date first,Vă rugăm să selectați postarea Data primei,
+Please select Price List,Vă rugăm să selectați lista de prețuri,
+Please select Program,Selectați Program,
+Please select Qty against item {0},Selectați Cantitate pentru elementul {0},
+Please select Sample Retention Warehouse in Stock Settings first,Vă rugăm să selectați mai întâi Warehouse de stocare a probelor din Setări stoc,
+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 Student Admission which is mandatory for the paid student applicant,Selectați admiterea studenților care este obligatorie pentru solicitantul studenților plătiți,
+Please select a BOM,Selectați un BOM,
+Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,Selectați un lot pentru articolul {0}. Nu se poate găsi un singur lot care să îndeplinească această cerință,
+Please select a Company,Vă rugăm să selectați o companie,
+Please select a batch,Selectați un lot,
+Please select a csv file,Vă rugăm să selectați un fișier csv,
+Please select a field to edit from numpad,Selectați un câmp de editat din numpad,
+Please select a table,Selectați un tabel,
+Please select a valid Date,Selectați o dată validă,
+Please select a value for {0} quotation_to {1},Vă rugăm să selectați o valoare de {0} {1} quotation_to,
+Please select a warehouse,Te rugăm să selectazi un depozit,
+Please select at least one domain.,Selectați cel puțin un domeniu.,
+Please select correct account,Vă rugăm să selectați contul corect,
+Please select date,Vă rugăm să selectați data,
+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 Company,Selectați compania,
+Please select the Multiple Tier Program type for more than one collection rules.,Selectați tipul de program cu mai multe niveluri pentru mai multe reguli de colectare.,
+Please select the assessment group other than 'All Assessment Groups',Selectați alt grup de evaluare decât &quot;Toate grupurile de evaluare&quot;,
+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 selectați 0} {întâi,
+Please set 'Apply Additional Discount On',Vă rugăm să setați &quot;Aplicați discount suplimentar pe&quot;,
+Please set 'Asset Depreciation Cost Center' in Company {0},Vă rugăm să setați &quot;Activ Center Amortizarea Cost&quot; în companie {0},
+Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Vă rugăm să setați &#39;Gain / Pierdere de cont privind Eliminarea activelor &quot;în companie {0},
+Please set Account in Warehouse {0} or Default Inventory Account in Company {1},Vă rugăm să configurați contul în depozit {0} sau contul implicit de inventar din companie {1},
+Please set B2C Limit in GST Settings.,Setați limita B2C în setările GST.,
+Please set Company,Stabiliți compania,
+Please set Company filter blank if Group By is 'Company',Filtru filtru de companie gol dacă grupul de grup este &quot;companie&quot;,
+Please set Default Payroll Payable Account in Company {0},Vă rugăm să setați Cont Cheltuieli suplimentare salarizare implicit în companie {0},
+Please set Depreciation related Accounts in Asset Category {0} or Company {1},Vă rugăm să setați Conturi aferente amortizării în categoria activelor {0} sau companie {1},
+Please set Email Address,Vă rugăm să setați adresa de e-mail,
+Please set GST Accounts in GST Settings,Vă rugăm să setați Conturi GST în Setări GST,
+Please set Hotel Room Rate on {},Vă rugăm să stabiliți tariful camerei la {},
+Please set Number of Depreciations Booked,Vă rugăm să setați Numărul de Deprecieri rezervat,
+Please set Unrealized Exchange Gain/Loss Account in Company {0},Vă rugăm să setați Contul de Cheltuiala / Venit din diferente de curs valutar in companie {0},
+Please set User ID field in an Employee record to set Employee Role,Vă rugăm să setați câmp ID de utilizator într-o înregistrare angajat să stabilească Angajat rol,
+Please set a default Holiday List for Employee {0} or Company {1},Vă rugăm să setați o valoare implicită Lista de vacanță pentru angajat {0} sau companie {1},
+Please set account in Warehouse {0},Vă rugăm să configurați un cont în Warehouse {0},
+Please set an active menu for Restaurant {0},Vă rugăm să setați un meniu activ pentru Restaurant {0},
+Please set associated account in Tax Withholding Category {0} against Company {1},Vă rugăm să setați contul asociat în categoria de reținere fiscală {0} împotriva companiei {1},
+Please set at least one row in the Taxes and Charges Table,Vă rugăm să setați cel puțin un rând în tabelul Impozite și taxe,
+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 account in Salary Component {0},Vă rugăm să setați contul implicit în Salariu Component {0},
+Please set default customer in Restaurant Settings,Alegeți clientul implicit în Setări restaurant,
+Please set default template for Leave Approval Notification in HR Settings.,Stabiliți șablonul prestabilit pentru notificarea de aprobare de ieșire din setările HR.,
+Please set default template for Leave Status Notification in HR Settings.,Stabiliți șablonul implicit pentru notificarea de stare la ieșire în setările HR.,
+Please set default {0} in Company {1},Vă rugăm să setați implicit {0} în {1} companie,
+Please set filter based on Item or Warehouse,Vă rugăm să setați filtru bazat pe postul sau depozit,
+Please set leave policy for employee {0} in Employee / Grade record,Vă rugăm să stabiliți politica de concediu pentru angajatul {0} în evidența Angajat / Grad,
+Please set recurring after saving,Vă rugăm să setați recurente după salvare,
+Please set the Company,Stabiliți compania,
+Please set the Customer Address,Vă rugăm să setați Adresa Clientului,
+Please set the Date Of Joining for employee {0},Vă rugăm să setați data de îmbarcare pentru angajat {0},
+Please set the Default Cost Center in {0} company.,Alegeți Centrul de cost implicit în compania {0}.,
+Please set the Email ID for the Student to send the Payment Request,Vă rugăm să setați ID-ul de e-mail pentru ca studentul să trimită Solicitarea de plată,
+Please set the Item Code first,Vă rugăm să setați mai întâi Codul elementului,
+Please set the Payment Schedule,Vă rugăm să setați Programul de plată,
+Please set the series to be used.,Setați seria care urmează să fie utilizată.,
+Please set {0} for address {1},Vă rugăm să setați {0} pentru adresa {1},
+Please setup Students under Student Groups,Configurați elevii din grupurile de studenți,
+Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',Vă rugăm să împărtășiți feedback-ul dvs. la antrenament făcând clic pe &quot;Feedback Training&quot; și apoi pe &quot;New&quot;,
+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 a valid 'From Case No.',"Vă rugăm să specificați un valabil ""Din cauza nr""",
+Please specify a valid Row ID for row {0} in table {1},Vă rugăm să specificați un ID rând valabil pentru rând {0} în tabelul {1},
+Please specify at least one attribute in the Attributes table,Vă rugăm să specificați cel puțin un atribut în tabelul Atribute,
+Please specify currency in Company,Vă rugăm să specificați în valută companie,
+Please specify either Quantity or Valuation Rate or both,Vă rugăm să specificați fie Cantitate sau Evaluează evaluare sau ambele,
+Please specify from/to range,Vă rugăm să precizați de la / la gama,
+Please supply the specified items at the best possible rates,Vă rugăm să furnizeze elementele specificate la cele mai bune tarife posibile,
+Please update your status for this training event,Actualizați starea dvs. pentru acest eveniment de instruire,
+Please wait 3 days before resending the reminder.,Așteptați 3 zile înainte de a retrimite mementourile.,
+Point of Sale,Point of Sale,
+Point-of-Sale,Punct-de-Vânzare,
+Point-of-Sale Profile,Profil Punct-de-Vânzare,
+Portal,Portal,
+Portal Settings,Setări portal,
+Possible Supplier,posibil furnizor,
+Postal Expenses,Cheltuieli poștale,
+Posting Date,Dată postare,
+Posting Date cannot be future date,Dată postare nu poate fi data viitoare,
+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.,
+Practitioner Schedule,Programul practicianului,
+Pre Sales,Vânzări pre,
+Preference,Preferinţă,
+Prescribed Procedures,Proceduri prescrise,
+Prescription,Reteta medicala,
+Prescription Dosage,Dozaj de prescripție,
+Prescription Duration,Durata prescrierii,
+Prescriptions,Prescriptiile,
+Present,Prezenta,
+Prev,Anterior,
+Preview,Previzualizați,
+Preview Salary Slip,Previzualizare Salariu alunecare,
+Previous Financial Year is not closed,Exercițiul financiar precedent nu este închis,
+Price,Preț,
+Price List,Lista Prețuri,
+Price List Currency not selected,Lista de pret Valuta nu selectat,
+Price List Rate,Lista de prețuri Rate,
+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 {0} is disabled or does not exist,Listă de prețuri {0} este dezactivat sau nu există,
+Price or product discount slabs are required,Este necesară plăci de reducere a prețului sau a produsului,
+Pricing,Stabilirea pretului,
+Pricing Rule,Regulă de stabilire a prețurilor,
+"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 Rule {0} is updated,Regula prețurilor {0} este actualizată,
+Pricing Rules are further filtered based on quantity.,Regulile de stabilire a prețurilor sunt filtrate în continuare în funcție de cantitate.,
+Primary Address Details,Detalii despre adresa primară,
+Primary Contact Details,Detalii de contact primare,
+Principal Amount,Sumă principală,
+Print Format,Print Format,
+Print IRS 1099 Forms,Tipărire formulare IRS 1099,
+Print Report Card,Print Print Card,
+Print Settings,Setări de imprimare,
+Print and Stationery,Imprimare și articole de papetărie,
+Print settings updated in respective print format,Setările de imprimare actualizate în format de imprimare respectiv,
+Print taxes with zero amount,Imprimă taxele cu suma zero,
+Printing and Branding,Imprimarea și Branding,
+Private Equity,Private Equity,
+Privilege Leave,Privilege concediu,
+Probation,probă,
+Probationary Period,Perioadă de probă,
+Procedure,Procedură,
+Process Day Book Data,Procesați datele despre cartea de zi,
+Process Master Data,Procesați datele de master,
+Processing Chart of Accounts and Parties,Procesarea Graficului de conturi și părți,
+Processing Items and UOMs,Prelucrare elemente și UOM-uri,
+Processing Party Addresses,Prelucrarea adreselor partidului,
+Processing Vouchers,Procesarea voucherelor,
+Procurement,achiziții publice,
+Produced Qty,Cantitate produsă,
+Product,Produs,
+Product Bundle,Bundle produs,
+Product Search,Cauta produse,
+Production,Producţie,
+Production Item,Producția Postul,
+Products,Instrumente,
+Profit and Loss,Profit și pierdere,
+Profit for the year,Profitul anului,
+Program,Program,
+Program in the Fee Structure and Student Group {0} are different.,Programul din structura taxelor și grupul de studenți {0} este diferit.,
+Program {0} does not exist.,Programul {0} nu există.,
+Program: ,Program:,
+Progress % for a task cannot be more than 100.,Progres% pentru o sarcină care nu poate fi mai mare de 100.,
+Project Collaboration Invitation,Colaborare proiect Invitație,
+Project Id,ID-ul proiectului,
+Project Manager,Manager de proiect,
+Project Name,Denumirea proiectului,
+Project Start Date,Data de începere a proiectului,
+Project Status,Status Proiect,
+Project Summary for {0},Rezumatul proiectului pentru {0},
+Project Update.,Actualizarea proiectului.,
+Project Value,Valoare proiect,
+Project activity / task.,Activitatea de proiect / sarcină.,
+Project master.,Maestru proiect.,
+Project-wise data is not available for Quotation,Date proiect-înțelept nu este disponibilă pentru ofertă,
+Projected,Proiectat,
+Projected Qty,Numărul estimat,
+Projected Quantity Formula,Formula de cantitate proiectată,
+Projects,proiecte,
+Property,Proprietate,
+Property already added,Proprietățile deja adăugate,
+Proposal Writing,Propunere de scriere,
+Proposal/Price Quote,Propunere / Citat pret,
+Prospecting,Prospectarea,
+Provisional Profit / Loss (Credit),Profit provizorie / Pierdere (Credit),
+Publications,Publicații,
+Publish Items on Website,Publica Articole pe site-ul,
+Published,Data publicării,
+Publishing,editare,
+Purchase,Cumpărarea,
+Purchase Amount,Suma cumpărată,
+Purchase Date,Data cumpărării,
+Purchase Invoice,Factura de cumpărare,
+Purchase Invoice {0} is already submitted,Factura de cumpărare {0} este deja depusă,
+Purchase Manager,Cumpărare Director,
+Purchase Master Manager,Cumpărare Maestru de Management,
+Purchase Order,Comandă de aprovizionare,
+Purchase Order Amount,Suma comenzii de cumpărare,
+Purchase Order Amount(Company Currency),Suma comenzii de cumpărare (moneda companiei),
+Purchase Order Date,Data comenzii de cumpărare,
+Purchase Order Items not received on time,Elemente de comandă de cumpărare care nu au fost primite la timp,
+Purchase Order number required for Item {0},Număr de comandă de aprovizionare necesare pentru postul {0},
+Purchase Order to Payment,Comandă de aprovizionare de plata,
+Purchase Order {0} is not submitted,Comandă {0} nu este prezentat,
+Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Comenzile de cumpărare nu sunt permise pentru {0} datorită unui punctaj din {1}.,
+Purchase Orders given to Suppliers.,A achiziționa ordine de date Furnizori.,
+Purchase Price List,Cumparare Lista de preturi,
+Purchase Receipt,Primirea de cumpărare,
+Purchase Receipt {0} is not submitted,Primirea de cumpărare {0} nu este prezentat,
+Purchase Tax Template,Achiziționa Format fiscală,
+Purchase User,Cumpărare de utilizare,
+Purchase orders help you plan and follow up on your purchases,Comenzile de aprovizionare vă ajuta să planificați și să urmați pe achizițiile dvs.,
+Purchasing,cumpărare,
+Purpose must be one of {0},Scopul trebuie să fie una dintre {0},
+Qty,Cantitate,
+Qty To Manufacture,Cantitate pentru fabricare,
+Qty Total,Cantitate totală,
+Qty for {0},Cantitate pentru {0},
+Qualification,Calificare,
+Quality,Calitate,
+Quality Action,Acțiune de calitate,
+Quality Goal.,Obiectivul de calitate.,
+Quality Inspection,Inspecție de calitate,
+Quality Inspection: {0} is not submitted for the item: {1} in row {2},Inspecție de calitate: {0} nu este trimis pentru articol: {1} în rândul {2},
+Quality Management,Managementul calității,
+Quality Meeting,Întâlnire de calitate,
+Quality Procedure,Procedura de calitate,
+Quality Procedure.,Procedura de calitate.,
+Quality Review,Evaluarea calității,
+Quantity,Cantitate,
+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 must be less than or equal to {0},Cantitatea trebuie sa fie mai mic sau egal cu {0},
+Quantity must not be more than {0},Cantitatea nu trebuie să fie mai mare de {0},
+Quantity required for Item {0} in row {1},Cantitatea necesară pentru postul {0} în rândul {1},
+Quantity should be greater than 0,Cantitatea trebuie sa fie mai mare decât 0,
+Quantity to Make,Cantitate de făcut,
+Quantity to Manufacture must be greater than 0.,Cantitatea să Fabricare trebuie sa fie mai mare decât 0.,
+Quantity to Produce,Cantitate de produs,
+Quantity to Produce can not be less than Zero,Cantitatea de produs nu poate fi mai mică decât Zero,
+Query Options,Opțiuni de interogare,
+Queued for replacing the BOM. It may take a few minutes.,În așteptare pentru înlocuirea BOM. Ar putea dura câteva minute.,
+Queued for updating latest price in all Bill of Materials. It may take a few minutes.,A intrat în așteptare pentru actualizarea ultimului preț în toate materialele. Ar putea dura câteva minute.,
+Quick Journal Entry,Quick Jurnal de intrare,
+Quot Count,Contele de numere,
+Quot/Lead %,Cota / Plumb%,
+Quotation,Ofertă,
+Quotation {0} is cancelled,Ofertă {0} este anulat,
+Quotation {0} not of type {1},Ofertă {0} nu de tip {1},
+Quotations,Cotațiile,
+"Quotations are proposals, bids you have sent to your customers","Cotațiile sunt propuneri, sumele licitate le-ați trimis clienților dvs.",
+Quotations received from Suppliers.,Cotatiilor primite de la furnizori.,
+Quotations: ,Cotațiile:,
+Quotes to Leads or Customers.,Citate la Oportunitati sau clienți.,
+RFQs are not allowed for {0} due to a scorecard standing of {1},CV-urile nu sunt permise pentru {0} datorită unui punctaj din {1},
+Range,Interval,
+Rate,Rată,
+Rate:,Rată:,
+Rating,evaluare,
+Raw Material,Material brut,
+Raw Materials,Materie prima,
+Raw Materials cannot be blank.,Materii Prime nu poate fi gol.,
+Re-open,Re-deschide,
+Read blog,Citiți blogul,
+Read the ERPNext Manual,Citiți manualul ERPNext,
+Reading Uploaded File,Citind fișierul încărcat,
+Real Estate,Imobiliare,
+Reason For Putting On Hold,Motivul pentru a pune în așteptare,
+Reason for Hold,Motiv pentru reținere,
+Reason for hold: ,Motivul de reținere:,
+Receipt,Chitanţă,
+Receipt document must be submitted,Document primire trebuie să fie depuse,
+Receivable,De încasat,
+Receivable Account,Cont Încasări,
+Received,Primit,
+Received On,Primit la,
+Received Quantity,Cantitate primită,
+Received Stock Entries,Înscrierile primite,
+Receiver List is empty. Please create Receiver List,Receptor Lista goala. Vă rugăm să creați Receiver Lista,
+Recipients,Destinatarii,
+Reconcile,Reconcilierea,
+"Record of all communications of type email, phone, chat, visit, etc.","Înregistrare a tuturor comunicărilor de tip e-mail, telefon, chat, vizita, etc.",
+Records,Înregistrări,
+Redirect URL,Redirecționare URL-ul,
+Ref,Re,
+Ref Date,Ref Data,
+Reference,Referință,
+Reference #{0} dated {1},Reference # {0} din {1},
+Reference Date,Data de referință,
+Reference Doctype must be one of {0},Referința Doctype trebuie să fie una dintre {0},
+Reference Document,Documentul de referință,
+Reference Document Type,Referință Document Type,
+Reference No & Reference Date is required for {0},Nu referință și de referință Data este necesar pentru {0},
+Reference No and Reference Date is mandatory for Bank transaction,De referință nr și de referință Data este obligatorie pentru tranzacție bancară,
+Reference No is mandatory if you entered Reference Date,De referință nu este obligatorie în cazul în care ați introdus Reference Data,
+Reference No.,Numărul de referință,
+Reference Number,Numar de referinta,
+Reference Owner,Proprietar Referință,
+Reference Type,Tipul Referință,
+"Reference: {0}, Item Code: {1} and Customer: {2}","Referință: {0}, Cod articol: {1} și Client: {2}",
+References,Referințe,
+Refresh Token,Actualizează Indicativ,
+Region,Regiune,
+Register,Înregistrare,
+Reject,Respinge,
+Rejected,Respinse,
+Related,Legate de,
+Relation with Guardian1,Relația cu Guardian1,
+Relation with Guardian2,Relația cu Guardian2,
+Release Date,Data eliberării,
+Reload Linked Analysis,Reîncărcați Analiza Legată,
+Remaining,Rămas,
+Remaining Balance,Balanța rămasă,
+Remarks,Remarci,
+Reminder to update GSTIN Sent,Memento pentru actualizarea mesajului GSTIN Trimis,
+Remove item if charges is not applicable to that item,Eliminați element cazul în care costurile nu se aplică în acest element,
+Removed items with no change in quantity or value.,Articole eliminate fară nici o schimbare de cantitate sau  valoare.,
+Reopen,Redeschide,
+Reorder Level,Nivel pentru re-comanda,
+Reorder Qty,Cantitatea de comandat,
+Repeat Customer Revenue,Repetați Venituri Clienți,
+Repeat Customers,Clienții repetate,
+Replace BOM and update latest price in all BOMs,Înlocuiește BOM și actualizează prețul recent în toate BOM-urile,
+Replied,A răspuns:,
+Replies,Răspunsuri,
+Report,Raport,
+Report Builder,Constructor Raport,
+Report Type,Tip Raport,
+Report Type is mandatory,Tip Raport obligatoriu,
+Reports,Rapoarte,
+Reqd By Date,Cerere livrare la data de,
+Reqd Qty,Reqd Cantitate,
+Request for Quotation,Cerere de ofertă,
+Request for Quotations,Cerere de Oferte,
+Request for Raw Materials,Cerere pentru materii prime,
+Request for purchase.,Cerere de achizitie.,
+Request for quotation.,Cerere de ofertă.,
+Requested Qty,Cant. Solicitată,
+"Requested Qty: Quantity requested for purchase, but not ordered.","A solicitat Cantitate: Cantitatea solicitate pentru achiziții, dar nu a ordonat.",
+Requesting Site,Solicitarea site-ului,
+Requesting payment against {0} {1} for amount {2},Se solicita plata contra {0} {1} pentru suma {2},
+Requestor,care a făcut cererea,
+Required On,Cerut pe,
+Required Qty,Cantitate ceruta,
+Required Quantity,Cantitatea necesară,
+Reschedule,Reprogramează,
+Research,Cercetare,
+Research & Development,Cercetare & Dezvoltare,
+Researcher,Cercetător,
+Resend Payment Email,Retrimiteți e-mail-ul de plată,
+Reserve Warehouse,Rezervați Depozitul,
+Reserved Qty,Cant. rezervata,
+Reserved Qty for Production,Cant. rezervata pentru producție,
+Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Cantitate rezervată pentru producție: cantitate de materii prime pentru fabricarea articolelor de fabricație.,
+"Reserved Qty: Quantity ordered for sale, but not delivered.","Rezervate Cantitate: Cantitatea comandat de vânzare, dar nu livrat.",
+Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Depozitul rezervat este obligatoriu pentru articolul {0} din materiile prime furnizate,
+Reserved for manufacturing,Rezervat pentru fabricare,
+Reserved for sale,Rezervat pentru vânzare,
+Reserved for sub contracting,Rezervat pentru subcontractare,
+Resistant,Rezistent,
+Resolve error and upload again.,Rezolvați eroarea și încărcați din nou.,
+Responsibilities,responsabilităţi,
+Rest Of The World,Restul lumii,
+Restart Subscription,Reporniți Abonament,
+Restaurant,Restaurant,
+Result Date,Data rezultatului,
+Result already Submitted,Rezultatul deja trimis,
+Resume,Reluare,
+Retail,Cu amănuntul,
+Retail & Wholesale,Retail & Wholesale,
+Retail Operations,Operațiunile de vânzare cu amănuntul,
+Retained Earnings,Venituri reținute,
+Retention Stock Entry,Reținerea stocului,
+Retention Stock Entry already created or Sample Quantity not provided,Reținerea stocului de stocare deja creată sau Cantitatea de eșantion care nu a fost furnizată,
+Return,Întoarcere,
+Return / Credit Note,Revenire / credit Notă,
+Return / Debit Note,Returnare / debit Notă,
+Returns,Se intoarce,
+Reverse Journal Entry,Intrare în jurnal invers,
+Review Invitation Sent,Examinarea invitației trimisă,
+Review and Action,Revizuire și acțiune,
+Role,Rol,
+Rooms Booked,Camere rezervate,
+Root Company,Companie de rădăcină,
+Root Type,Rădăcină Tip,
+Root Type is mandatory,Rădăcină de tip este obligatorie,
+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,
+Round Off,Rotunji,
+Rounded Total,Rotunjite total,
+Route,Traseu,
+Row # {0}: ,Rând # {0}:,
+Row # {0}: Batch No must be same as {1} {2},Row # {0}: Lot nr trebuie să fie aceeași ca și {1} {2},
+Row # {0}: Cannot return more than {1} for Item {2},Row # {0}: nu se pot întoarce mai mult {1} pentru postul {2},
+Row # {0}: Rate cannot be greater than the rate used in {1} {2},Rândul # {0}: Rata nu poate fi mai mare decât rata folosită în {1} {2},
+Row # {0}: Serial No is mandatory,Row # {0}: Nu serial este obligatorie,
+Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: Serial No {1} nu se potrivește cu {2} {3},
+Row #{0} (Payment Table): Amount must be negative,Rândul # {0} (tabelul de plată): Suma trebuie să fie negativă,
+Row #{0} (Payment Table): Amount must be positive,Rândul # {0} (tabelul de plată): Suma trebuie să fie pozitivă,
+Row #{0}: Account {1} does not belong to company {2},Rândul # {0}: Contul {1} nu aparține companiei {2},
+Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Rândul # {0}: Suma alocată nu poate fi mai mare decât suma rămasă.,
+"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Rând # {0}: {1} activ nu poate fi prezentat, este deja {2}",
+Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,Rândul # {0}: nu se poate seta Rata dacă suma este mai mare decât suma facturată pentru articolul {1}.,
+Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Rând # {0}: Data de lichidare {1} nu poate fi înainte de Cheque Data {2},
+Row #{0}: Duplicate entry in References {1} {2},Rândul # {0}: intrarea duplicat în referințe {1} {2},
+Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Row # {0}: Data livrării așteptată nu poate fi înainte de data comenzii de achiziție,
+Row #{0}: Item added,Rândul # {0}: articol adăugat,
+Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Rând # {0}: Jurnal de intrare {1} nu are cont {2} sau deja compensată împotriva unui alt voucher,
+Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Row # {0}: Nu este permis să schimbe furnizorul ca Comandă există deja,
+Row #{0}: Please set reorder quantity,Row # {0}: Va rugam sa seta cantitatea reordona,
+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}: Qty increased by 1,Rândul # {0}: cantitatea a crescut cu 1,
+Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Rata trebuie să fie aceeași ca și {1}: {2} ({3} / {4}),
+Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Rândul # {0}: Tipul de document de referință trebuie să fie una dintre revendicările de cheltuieli sau intrări în jurnal,
+"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Rând # {0}: Tip document de referință trebuie să fie unul dintre comandă cumparare, factură sau Jurnal de intrare",
+Row #{0}: Rejected Qty can not be entered in Purchase Return,Row # {0}: Respins Cantitate nu pot fi introduse în Purchase Întoarcere,
+Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Row # {0}: Respins Warehouse este obligatorie împotriva postul respins {1},
+Row #{0}: Reqd by Date cannot be before Transaction Date,Rândul # {0}: Reqd by Date nu poate fi înainte de data tranzacției,
+Row #{0}: Set Supplier for item {1},Row # {0}: Set Furnizor de produs {1},
+Row #{0}: Status must be {1} for Invoice Discounting {2},Rândul # {0}: starea trebuie să fie {1} pentru reducerea facturilor {2},
+"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Rândul # {0}: lotul {1} are doar {2} qty. Selectați un alt lot care are {3} qty disponibil sau împărți rândul în mai multe rânduri, pentru a livra / emite din mai multe loturi",
+Row #{0}: Timings conflicts with row {1},Rând # {0}: conflicte timpilor cu rândul {1},
+Row #{0}: {1} can not be negative for item {2},Row # {0}: {1} nu poate fi negativ pentru elementul {2},
+Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Rândul nr {0}: Suma nu poate fi mai mare decât așteptarea Suma împotriva revendicării cheltuieli {1}. În așteptarea Suma este {2},
+Row {0} : Operation is required against the raw material item {1},Rândul {0}: operația este necesară împotriva elementului de materie primă {1},
+Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Rândul {0} # Suma alocată {1} nu poate fi mai mare decât suma nerevendicată {2},
+Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Rândul {0} # Articol {1} nu poate fi transferat mai mult de {2} față de comanda de aprovizionare {3},
+Row {0}# Paid Amount cannot be greater than requested advance amount,Rândul {0} # Suma plătită nu poate fi mai mare decât suma solicitată în avans,
+Row {0}: Activity Type is mandatory.,Rândul {0}: Activitatea de tip este obligatorie.,
+Row {0}: Advance against Customer must be credit,Row {0}: avans Clientul trebuie să fie de credit,
+Row {0}: Advance against Supplier must be debit,Row {0}: Advance împotriva Furnizor trebuie să fie de debit,
+Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Rândul {0}: Suma alocată {1} trebuie să fie mai mic sau egal cu suma de plată de intrare {2},
+Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Rândul {0}: Suma alocată {1} trebuie să fie mai mic sau egal cu factura suma restanta {2},
+Row {0}: An Reorder entry already exists for this warehouse {1},Rând {0}: O intrare de Comandă există deja pentru acest depozit {1},
+Row {0}: Bill of Materials not found for the Item {1},Rândul {0}: Lista de materiale nu a fost găsit pentru elementul {1},
+Row {0}: Conversion Factor is mandatory,Rând {0}: Factorul de conversie este obligatorie,
+Row {0}: Cost center is required for an item {1},Rând {0}: este necesar un centru de cost pentru un element {1},
+Row {0}: Credit entry can not be linked with a {1},Rând {0}: intrare de credit nu poate fi legat de o {1},
+Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Rând {0}: Moneda de BOM # {1} ar trebui să fie egal cu moneda selectată {2},
+Row {0}: Debit entry can not be linked with a {1},Rând {0}: debit de intrare nu poate fi legat de o {1},
+Row {0}: Depreciation Start Date is required,Rând {0}: este necesară începerea amortizării,
+Row {0}: Enter location for the asset item {1},Rând {0}: introduceți locația pentru elementul de activ {1},
+Row {0}: Exchange Rate is mandatory,Row {0}: Cursul de schimb este obligatoriu,
+Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Rând {0}: Valoarea așteptată după viața utilă trebuie să fie mai mică decât suma brută de achiziție,
+Row {0}: From Time and To Time is mandatory.,Rândul {0}: De la timp și de Ora este obligatorie.,
+Row {0}: From Time and To Time of {1} is overlapping with {2},Rândul {0}: De la timp și Ora {1} se suprapune cu {2},
+Row {0}: From time must be less than to time,Rândul {0}: Din timp trebuie să fie mai mic decât în timp,
+Row {0}: Hours value must be greater than zero.,Rândul {0}: Valoarea ore trebuie să fie mai mare decât zero.,
+Row {0}: Invalid reference {1},Rândul {0}: referință invalid {1},
+Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Rând {0}: Parte / conturi nu se potrivește cu {1} / {2} din {3} {4},
+Row {0}: Party Type and Party is required for Receivable / Payable account {1},Row {0}: Partidul Tipul și Partidul este necesar pentru creanțe / cont plateste {1},
+Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Rând {0}: Plata împotriva Vânzări / Ordinului de Procurare ar trebui să fie întotdeauna marcate ca avans,
+Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Rând {0}: Vă rugăm să verificați ""Este Advance"" împotriva Cont {1} dacă aceasta este o intrare în avans.",
+Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,Rândul {0}: Vă rugăm să setați motivul scutirii de taxe în impozitele și taxele de vânzare,
+Row {0}: Please set the Mode of Payment in Payment Schedule,Rândul {0}: Vă rugăm să setați modul de plată în programul de plată,
+Row {0}: Please set the correct code on Mode of Payment {1},Rândul {0}: Vă rugăm să setați codul corect pe Modul de plată {1},
+Row {0}: Qty is mandatory,Rând {0}: Cant este obligatorie,
+Row {0}: Quality Inspection rejected for item {1},Rândul {0}: Inspecția de calitate a fost respinsă pentru articolul {1},
+Row {0}: UOM Conversion Factor is mandatory,Row {0}: Factorul de conversie UOM este obligatorie,
+Row {0}: select the workstation against the operation {1},Rând {0}: selectați stația de lucru pentru operația {1},
+Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Rând {0}: {1} Numerele de serie necesare pentru articolul {2}. Ați oferit {3}.,
+Row {0}: {1} must be greater than 0,Rând {0}: {1} trebuie să fie mai mare de 0,
+Row {0}: {1} {2} does not match with {3},Rând {0}: {1} {2} nu se potrivește cu {3},
+Row {0}:Start Date must be before End Date,Rând {0}: Data începerii trebuie să fie înainte de Data de încheiere,
+Rows with duplicate due dates in other rows were found: {0},Au fost găsite rânduri cu date scadente în alte rânduri: {0},
+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.,
+S.O. No.,SO No.,
+SGST Amount,Suma SGST,
+SO Qty,SO Cantitate,
+Safety Stock,Stoc de siguranta,
+Salary,Salariu,
+Salary Slip ID,ID-ul de salarizare alunecare,
+Salary Slip of employee {0} already created for this period,Platā angajatului {0} deja creat pentru această perioadă,
+Salary Slip of employee {0} already created for time sheet {1},Salariu de alunecare angajat al {0} deja creat pentru foaie de timp {1},
+Salary Slip submitted for period from {0} to {1},Plata salariului trimisă pentru perioada de la {0} la {1},
+Salary Structure Assignment for Employee already exists,Atribuirea structurii salariale pentru angajat există deja,
+Salary Structure Missing,Structura de salarizare lipsă,
+Salary Structure must be submitted before submission of Tax Ememption Declaration,Structura salariului trebuie depusă înainte de depunerea Declarației de eliberare de impozite,
+Salary Structure not found for employee {0} and date {1},Structura salarială nu a fost găsită pentru angajat {0} și data {1},
+Salary Structure should have flexible benefit component(s) to dispense benefit amount,Structura salariilor ar trebui să aibă componente flexibile pentru beneficiu pentru a renunța la suma beneficiilor,
+"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Salariu au fost deja procesate pentru perioada între {0} și {1}, Lăsați perioada de aplicare nu poate fi între acest interval de date.",
+Sales,Vânzări,
+Sales Account,Cont de vanzari,
+Sales Expenses,Cheltuieli de Vânzare,
+Sales Funnel,Pâlnie Vânzări,
+Sales Invoice,Factură de vânzări,
+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 Manager,Director De Vânzări,
+Sales Master Manager,Vânzări Maestru de Management,
+Sales Order,Comandă de vânzări,
+Sales Order Item,Comandă de vânzări Postul,
+Sales Order required for Item {0},Ordinul de vânzări necesar pentru postul {0},
+Sales Order to Payment,Comanda de vânzări la plată,
+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 {1},Comandă de vânzări {0} este {1},
+Sales Orders,Comenzi de Vânzări,
+Sales Partner,Partener de vânzări,
+Sales Pipeline,Conductă de Vânzări,
+Sales Price List,Lista de prețuri de vânzare,
+Sales Return,Vânzări de returnare,
+Sales Summary,Rezumat Vânzări,
+Sales Tax Template,Format impozitul pe vânzări,
+Sales Team,Echipa de vânzări,
+Sales User,Vânzări de utilizare,
+Sales and Returns,Vânzări și returnări,
+Sales campaigns.,Campanii de vânzări.,
+Sales orders are not available for production,Comenzile de vânzări nu sunt disponibile pentru producție,
+Salutation,Salut,
+Same Company is entered more than once,Aceeași societate este înscris de mai multe ori,
+Same item cannot be entered multiple times.,Același articol nu poate fi introdus de mai multe ori.,
+Same supplier has been entered multiple times,Același furnizor a fost introdus de mai multe ori,
+Sample,Exemplu,
+Sample Collection,Colectie de mostre,
+Sample quantity {0} cannot be more than received quantity {1},Cantitatea de probe {0} nu poate fi mai mare decât cantitatea primită {1},
+Sanctioned,consacrat,
+Sanctioned Amount,Sancționate Suma,
+Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sancționat Suma nu poate fi mai mare decât revendicarea Suma în rândul {0}.,
+Sand,Nisip,
+Saturday,Sâmbătă,
+Saved,Salvat,
+Saving {0},Salvarea {0},
+Scan Barcode,Scanează codul de bare,
+Schedule,Program,
+Schedule Admission,Programați admiterea,
+Schedule Course,Curs orar,
+Schedule Date,Program Data,
+Schedule Discharge,Programați descărcarea,
+Scheduled,Programat,
+Scheduled Upto,Programată până,
+"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Programări pentru suprapunerile {0}, doriți să continuați după ce ați sări peste sloturile suprapuse?",
+Score cannot be greater than Maximum Score,Scorul nu poate fi mai mare decât Scorul maxim,
+Score must be less than or equal to 5,Scorul trebuie să fie mai mică sau egală cu 5,
+Scorecards,Scorecardurilor,
+Scrapped,dezmembrate,
+Search,Căutare,
+Search Results,rezultatele cautarii,
+Search Sub Assemblies,Căutare subansambluri,
+"Search by item code, serial number, batch no or barcode","Căutați după codul de articol, numărul de serie, numărul lotului sau codul de bare",
+"Seasonality for setting budgets, targets etc.","Sezonalitatea pentru stabilirea bugetelor, obiective etc.",
+Secret Key,Cheie secreta,
+Secretary,Secretar,
+Section Code,Codul secțiunii,
+Secured Loans,Împrumuturi garantate,
+Securities & Commodity Exchanges,A Valorilor Mobiliare și Burselor de Mărfuri,
+Securities and Deposits,Titluri de valoare și depozite,
+See All Articles,Vezi toate articolele,
+See all open tickets,Vedeți toate biletele deschise,
+See past orders,Vezi comenzile anterioare,
+See past quotations,Vezi citate anterioare,
+Select,Selectează,
+Select Alternate Item,Selectați elementul alternativ,
+Select Attribute Values,Selectați valorile atributelor,
+Select BOM,Selectați BOM,
+Select BOM and Qty for Production,Selectați BOM și Cant pentru producție,
+"Select BOM, Qty and For Warehouse","Selectați BOM, Qty și For Warehouse",
+Select Batch,Selectați lotul,
+Select Batch Numbers,Selectați numerele lotului,
+Select Brand...,Selectați marca ...,
+Select Company,Selectați Companie,
+Select Company...,Selectați compania ...,
+Select Customer,Selectați Client,
+Select Days,Selectați Zile,
+Select Default Supplier,Selectați Furnizor implicit,
+Select DocType,Selectați DocType,
+Select Fiscal Year...,Selectați Anul fiscal ...,
+Select Item (optional),Selectați elementul (opțional),
+Select Items based on Delivery Date,Selectați elementele bazate pe data livrării,
+Select Items to Manufacture,Selectați elementele de Fabricare,
+Select Loyalty Program,Selectați programul de loialitate,
+Select Patient,Selectați pacientul,
+Select Possible Supplier,Selectați Posibil furnizor,
+Select Property,Selectați proprietatea,
+Select Quantity,Selectați Cantitate,
+Select Serial Numbers,Selectați numerele de serie,
+Select Target Warehouse,Selectați Target Warehouse,
+Select Warehouse...,Selectați Depozit ...,
+Select an account to print in account currency,Selectați un cont pentru a imprima în moneda contului,
+Select an employee to get the employee advance.,Selectați un angajat pentru a avansa angajatul.,
+Select at least one value from each of the attributes.,Selectați cel puțin o valoare din fiecare dintre atribute.,
+Select change amount account,cont Selectați suma schimbare,
+Select company first,Selectați mai întâi compania,
+Select students manually for the Activity based Group,Selectați manual elevii pentru grupul bazat pe activități,
+Select the customer or supplier.,Selectați clientul sau furnizorul.,
+Select the nature of your business.,Selectați natura afacerii dumneavoastră.,
+Select the program first,Selectați mai întâi programul,
+Select to add Serial Number.,Selectați pentru a adăuga număr de serie.,
+Select your Domains,Selectați-vă domeniile,
+Selected Price List should have buying and selling fields checked.,Lista de prețuri selectată ar trebui să verifice câmpurile de cumpărare și vânzare.,
+Sell,Vinde,
+Selling,Vânzare,
+Selling Amount,Vanzarea Suma,
+Selling Price List,Listă Prețuri de Vânzare,
+Selling Rate,Rata de vanzare,
+"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 Grant Review Email,Trimiteți e-mailul de examinare a granturilor,
+Send Now,Trimite Acum,
+Send SMS,Trimite SMS,
+Send mass SMS to your contacts,Trimite SMS-uri în masă a persoanelor de contact,
+Sensitivity,Sensibilitate,
+Sent,Trimis,
+Serial No and Batch,Serial și Lot nr,
+Serial No is mandatory for Item {0},Nu serial este obligatorie pentru postul {0},
+Serial No {0} does not belong to Batch {1},Numărul de serie {0} nu aparține lotului {1},
+Serial No {0} does not belong to Delivery Note {1},Serial No {0} nu aparține de 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 belong to any Warehouse,Serial nr {0} nu apartine nici unei Warehouse,
+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 found,Serial nr {0} nu a fost găsit,
+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 Nos Required for Serialized Item {0},Serial nr necesare pentru postul serializat {0},
+Serial Number: {0} is already referenced in Sales Invoice: {1},Numărul de serie: {0} este deja menționat în factura de vânzare: {1},
+Serial Numbers,Numere de serie,
+Serial Numbers in row {0} does not match with Delivery Note,Numerele de serie din rândul {0} nu se potrivesc cu Nota de livrare,
+Serial no {0} has been already returned,Numărul serial {0} nu a fost deja returnat,
+Serial number {0} entered more than once,Număr de serie {0} a intrat de mai multe ori,
+Serialized Inventory,Inventarul serializat,
+Series Updated,Seria Actualizat,
+Series Updated Successfully,Seria Actualizat cu succes,
+Series is mandatory,Seria este obligatorie,
+Series {0} already used in {1},Series {0} folosit deja în {1},
+Service,Servicii,
+Service Expense,Cheltuieli de serviciu,
+Service Level Agreement,Acord privind nivelul serviciilor,
+Service Level Agreement.,Acord privind nivelul serviciilor.,
+Service Level.,Nivel de servicii.,
+Service Stop Date cannot be after Service End Date,Dată de încetare a serviciului nu poate fi după Data de încheiere a serviciului,
+Service Stop Date cannot be before Service Start Date,Data de începere a serviciului nu poate fi înaintea datei de începere a serviciului,
+Services,Servicii,
+"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Seta valorile implicite, cum ar fi Compania, valutar, Current Anul fiscal, etc",
+Set Details,Setați detalii,
+Set New Release Date,Setați noua dată de lansare,
+Set Project and all Tasks to status {0}?,Setați proiectul și toate sarcinile la starea {0}?,
+Set Status,Setați starea,
+Set Tax Rule for shopping cart,Set Regula fiscală pentru coșul de cumpărături,
+Set as Closed,Setați ca închis,
+Set as Completed,Setați ca Finalizat,
+Set as Default,Setat ca implicit,
+Set as Lost,Setați ca Lost,
+Set as Open,Setați ca Deschis,
+Set default inventory account for perpetual inventory,Setați contul inventarului implicit pentru inventarul perpetuu,
+Set this if the customer is a Public Administration company.,Setați acest lucru dacă clientul este o companie de administrare publică.,
+Set {0} in asset category {1} or company {2},Setați {0} în categoria de active {1} sau în companie {2},
+"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Setarea Evenimente la {0}, deoarece angajatul atașat la mai jos de vânzare Persoanele care nu are un ID de utilizator {1}",
+Setting defaults,Setarea valorilor implicite,
+Setting up Email,Configurarea e-mail,
+Setting up Email Account,Configurarea contului de e-mail,
+Setting up Employees,Configurarea angajati,
+Setting up Taxes,Configurarea Impozite,
+Setting up company,Înființarea companiei,
+Settings,Setări,
+"Settings for online shopping cart such as shipping rules, price list etc.","Setări pentru cosul de cumparaturi on-line, cum ar fi normele de transport maritim, lista de preturi, etc.",
+Settings for website homepage,Setările pentru pagina de start site-ul web,
+Settings for website product listing,Setări pentru listarea produselor site-ului web,
+Settled,Stabilit,
+Setup Gateway accounts.,Setup conturi Gateway.,
+Setup SMS gateway settings,Setări de configurare SMS gateway-ul,
+Setup cheque dimensions for printing,Dimensiunile de instalare pentru imprimare de verificare,
+Setup default values for POS Invoices,Configurați valorile implicite pentru facturile POS,
+Setup mode of POS (Online / Offline),Modul de configurare a POS (online / offline),
+Setup your Institute in ERPNext,Configurați-vă Institutul în ERPNext,
+Share Balance,Soldul acțiunilor,
+Share Ledger,Împărțiți Registru Contabil,
+Share Management,Gestiune partajare,
+Share Transfer,Trimiteți transferul,
+Share Type,Tipul de distribuire,
+Shareholder,Acționar,
+Ship To State,Transport către stat,
+Shipments,Transporturile,
+Shipping,Transport,
+Shipping Address,Adresa de livrare,
+"Shipping Address does not have country, which is required for this Shipping Rule","Adresa de expediere nu are țara, care este necesară pentru această regulă de transport",
+Shipping rule only applicable for Buying,Regulă de expediere aplicabilă numai pentru cumpărături,
+Shipping rule only applicable for Selling,Regulă de expediere aplicabilă numai pentru vânzare,
+Shopify Supplier,Furnizor de magazin,
+Shopping Cart,Cosul de cumparaturi,
+Shopping Cart Settings,Setări Cosul de cumparaturi,
+Short Name,Numele scurt,
+Shortage Qty,Lipsă Cantitate,
+Show Completed,Spectacol finalizat,
+Show Cumulative Amount,Afișați suma cumulată,
+Show Employee,Afișați angajatul,
+Show Open,Afișați deschis,
+Show Opening Entries,Afișare intrări de deschidere,
+Show Payment Details,Afișați detaliile de plată,
+Show Return Entries,Afișați înregistrările returnate,
+Show Salary Slip,Afișează Salariu alunecare,
+Show Variant Attributes,Afișați atribute variate,
+Show Variants,Arată Variante,
+Show closed,Afișează închis,
+Show exploded view,Afișați vizualizarea explodată,
+Show only POS,Afișați numai POS,
+Show unclosed fiscal year's P&L balances,Afișați soldurile L P &amp; anul fiscal unclosed lui,
+Show zero values,Afiseaza valorile nule,
+Sick Leave,A concediului medical,
+Silt,Nămol,
+Single Variant,Varianta unică,
+Single unit of an Item.,Unitate unică a unui articol.,
+"Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}","Scăderea listei de alocare pentru următorii angajați, deoarece înregistrările privind alocarea listei există deja împotriva acestora. {0}",
+"Skipping Salary Structure Assignment for the following employees, as Salary Structure Assignment records already exists against them. {0}","Trecerea alocării structurii salariale pentru următorii angajați, întrucât înregistrările privind structura salariului există deja împotriva lor {0}",
+Slideshow,Slideshow,
+Slots for {0} are not added to the schedule,Sloturile pentru {0} nu sunt adăugate la program,
+Small,Mic,
+Soap & Detergent,Soap & Detergent,
+Software,Software,
+Software Developer,Software Developer,
+Softwares,Softwares,
+Soil compositions do not add up to 100,Compozițiile solului nu adaugă până la 100,
+Sold,Vândut,
+Some emails are invalid,Unele e-mailuri sunt nevalide,
+Some information is missing,Lipsesc unele informații,
+Something went wrong!,Ceva a mers prost!,
+"Sorry, Serial Nos cannot be merged","Ne pare rău, Serial nr nu se pot uni",
+Source,Sursă,
+Source Name,sursa Nume,
+Source Warehouse,Depozit Sursă,
+Source and Target Location cannot be same,Sursa și locația țintă nu pot fi identice,
+Source and target warehouse cannot be same for row {0},Sursă și depozit țintă nu poate fi același pentru rând {0},
+Source and target warehouse must be different,Sursa și depozitul țintă trebuie să fie diferit,
+Source of Funds (Liabilities),Sursa fondurilor (pasive),
+Source warehouse is mandatory for row {0},Depozit sursă este obligatorie pentru rând {0},
+Specified BOM {0} does not exist for Item {1},BOM specificată {0} nu există pentru postul {1},
+Split,Despică,
+Split Batch,Split Lot,
+Split Issue,Emisiune separată,
+Sports,Sport,
+Staffing Plan {0} already exist for designation {1},Planul de personal {0} există deja pentru desemnare {1},
+Standard,Standard,
+Standard Buying,Cumpararea Standard,
+Standard Selling,Vânzarea standard,
+Standard contract terms for Sales or Purchase.,Clauzele contractuale standard pentru vânzări sau de cumpărare.,
+Start Date,Data începerii,
+Start Date of Agreement can't be greater than or equal to End Date.,Data de începere a acordului nu poate fi mai mare sau egală cu data de încheiere.,
+Start Year,Anul de începere,
+"Start and end dates not in a valid Payroll Period, cannot calculate {0}","Datele de început și de încheiere care nu sunt într-o perioadă de salarizare valabilă, nu pot fi calculate {0}",
+"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Datele de începere și de sfârșit nu se află într-o perioadă de salarizare valabilă, nu pot calcula {0}.",
+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},
+Start date should be less than end date for task {0},Data de începere ar trebui să fie mai mică decât data de încheiere pentru sarcina {0},
+Start day is greater than end day in task '{0}',Ziua de început este mai mare decât ziua de sfârșit în sarcina &quot;{0}&quot;,
+Start on,Începe,
+State,Stat,
+State/UT Tax,Impozitul de stat / UT,
+Statement of Account,Extras de cont,
+Status must be one of {0},Statusul trebuie să fie unul din {0},
+Stock,Stoc,
+Stock Adjustment,Ajustarea stoc,
+Stock Analytics,Analytics stoc,
+Stock Assets,Active Stoc,
+Stock Available,Stoc disponibil,
+Stock Balance,Stoc Sold,
+Stock Entries already created for Work Order ,Înregistrări stoc deja create pentru comanda de lucru,
+Stock Entry,Stoc de intrare,
+Stock Entry {0} created,Arhivă de intrare {0} creat,
+Stock Entry {0} is not submitted,Stock intrare {0} nu este prezentat,
+Stock Expenses,Cheltuieli stoc,
+Stock In Hand,Stoc în mână,
+Stock Items,stoc,
+Stock Ledger,Registru Contabil Stocuri,
+Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Stocul Ledger Înscrieri și GL intrările sunt postate pentru selectate Veniturile achiziție,
+Stock Levels,Niveluri stoc,
+Stock Liabilities,Pasive stoc,
+Stock Options,Opțiuni pe acțiuni,
+Stock Qty,Cota stocului,
+Stock Received But Not Billed,"Stock primite, dar nu Considerat",
+Stock Reports,Rapoarte de stoc,
+Stock Summary,Rezumat Stoc,
+Stock Transactions,Tranzacții de stoc,
+Stock UOM,Stoc UOM,
+Stock Value,Valoare stoc,
+Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},echilibru stoc în Serie {0} va deveni negativ {1} pentru postul {2} la Depozitul {3},
+Stock cannot be updated against Delivery Note {0},Stock nu poate fi actualizat împotriva livrare Nota {0},
+Stock cannot be updated against Purchase Receipt {0},Stock nu poate fi actualizat cu confirmare de primire {0} Purchase,
+Stock cannot exist for Item {0} since has variants,Stock nu poate exista pentru postul {0} deoarece are variante,
+Stock transactions before {0} are frozen,Tranzacțiilor bursiere înainte de {0} sunt înghețate,
+Stop,Oprire,
+Stopped,Oprita,
+"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Oprirea comenzii de lucru nu poate fi anulată, deblocați mai întâi pentru a anula",
+Stores,Magazine,
+Structures have been assigned successfully,Structurile au fost alocate cu succes,
+Student,Student,
+Student Activity,Activitatea studenților,
+Student Address,Adresa studenților,
+Student Admissions,Admitere Student,
+Student Attendance,Participarea studenților,
+"Student Batches help you track attendance, assessments and fees for students","Student Sarjele ajută să urmăriți prezență, evaluările și taxele pentru studenți",
+Student Email Address,Adresa de e-mail Student,
+Student Email ID,ID-ul de student e-mail,
+Student Group,Grupul studențesc,
+Student Group Strength,Grupul Forței Studenților,
+Student Group is already updated.,Grupul de studenți este deja actualizat.,
+Student Group: ,Grupul studenților:,
+Student ID,Carnet de student,
+Student ID: ,Carnet de student:,
+Student LMS Activity,Activitatea LMS a studenților,
+Student Mobile No.,Elev mobil Nr,
+Student Name,Numele studentului,
+Student Name: ,Numele studentului:,
+Student Report Card,Student Card de raportare,
+Student is already enrolled.,Student este deja înscris.,
+Student {0} - {1} appears Multiple times in row {2} & {3},Elev {0} - {1} apare ori multiple în rândul {2} &amp; {3},
+Student {0} does not belong to group {1},Studentul {0} nu aparține grupului {1},
+Student {0} exist against student applicant {1},Student {0} există împotriva solicitantului de student {1},
+"Students are at the heart of the system, add all your students","Studenții sunt în centrul sistemului, adăugați toți elevii",
+Sub Assemblies,Sub Assemblies,
+Sub Type,Subtipul,
+Sub-contracting,Sub-contractare,
+Subcontract,subcontract,
+Subject,Subiect,
+Submit,Trimite,
+Submit Proof,Trimiteți dovada,
+Submit Salary Slip,Prezenta Salariul Slip,
+Submit this Work Order for further processing.,Trimiteți acest ordin de lucru pentru o prelucrare ulterioară.,
+Submit this to create the Employee record,Trimiteți acest lucru pentru a crea înregistrarea angajatului,
+Submitting Salary Slips...,Trimiterea buletinelor de salariu ...,
+Subscription,Abonament,
+Subscription Management,Managementul abonamentelor,
+Subscriptions,Abonamente,
+Subtotal,subtotală,
+Successful,De succes,
+Successfully Reconciled,Împăcați cu succes,
+Successfully Set Supplier,Setați cu succes furnizorul,
+Successfully created payment entries,Au fost create intrări de plată cu succes,
+Successfully deleted all transactions related to this company!,Șters cu succes toate tranzacțiile legate de aceasta companie!,
+Sum of Scores of Assessment Criteria needs to be {0}.,Suma Scorurile de criterii de evaluare trebuie să fie {0}.,
+Sum of points for all goals should be 100. It is {0},Suma de puncte pentru toate obiectivele ar trebui să fie 100. este {0},
+Summary,Rezumat,
+Summary for this month and pending activities,Rezumat pentru această lună și activități în așteptarea,
+Summary for this week and pending activities,Rezumat pentru această săptămână și a activităților în curs,
+Sunday,Duminică,
+Suplier,furnizo,
+Supplier,Furnizor,
+Supplier Group,Grupul de furnizori,
+Supplier Group master.,Managerul grupului de furnizori.,
+Supplier Id,Furnizor Id,
+Supplier Invoice Date cannot be greater than Posting Date,Furnizor Data facturii nu poate fi mai mare decât postare Data,
+Supplier Invoice No,Furnizor Factura Nu,
+Supplier Invoice No exists in Purchase Invoice {0},Furnizor Factura nr există în factură Purchase {0},
+Supplier Name,Furnizor Denumire,
+Supplier Part No,Furnizor de piesa,
+Supplier Quotation,Furnizor ofertă,
+Supplier Scorecard,Scorul de performanță al furnizorului,
+Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Furnizor Depozit obligatoriu pentru contractate sub-cumparare Primirea,
+Supplier database.,Baza de date furnizor.,
+Supplier {0} not found in {1},Furnizorul {0} nu a fost găsit în {1},
+Supplier(s),Furnizor (e),
+Supplies made to UIN holders,Materialele furnizate deținătorilor UIN,
+Supplies made to Unregistered Persons,Furnizare pentru persoane neînregistrate,
+Suppliies made to Composition Taxable Persons,Cupluri făcute persoanelor impozabile din componență,
+Supply Type,Tip de aprovizionare,
+Support,Suport,
+Support Analytics,Suport Analytics,
+Support Settings,Setări de sprijin,
+Support Tickets,Bilete de sprijin,
+Support queries from customers.,Interogări de suport din partea clienților.,
+Susceptible,Susceptibil,
+Sync has been temporarily disabled because maximum retries have been exceeded,"Sincronizarea a fost temporar dezactivată, deoarece au fost depășite încercările maxime",
+Syntax error in condition: {0},Eroare de sintaxă în stare: {0},
+Syntax error in formula or condition: {0},Eroare de sintaxă în formulă sau stare: {0},
+System Manager,System Manager,
+TDS Rate %,Rata TDS%,
+Tap items to add them here,Atingeți elementele pentru a le adăuga aici,
+Target,Țintă,
+Target ({}),Țintă ({}),
+Target On,Țintă pe,
+Target Warehouse,Depozit Țintă,
+Target warehouse is mandatory for row {0},Depozit țintă este obligatorie pentru rând {0},
+Task,Sarcină,
+Tasks,Sarcini,
+Tasks have been created for managing the {0} disease (on row {1}),S-au creat sarcini pentru gestionarea bolii {0} (pe rândul {1}),
+Tax,Impozite,
+Tax Assets,Active Fiscale,
+Tax Category,Categoria fiscală,
+Tax Category for overriding tax rates.,Categorie de impozite pentru cote de impozitare superioare.,
+"Tax Category has been changed to ""Total"" because all the Items are non-stock items",Categoria de taxe a fost modificată la &quot;Total&quot; deoarece toate elementele nu sunt elemente stoc,
+Tax ID,ID impozit,
+Tax Id: ,Cod fiscal:,
+Tax Rate,Cota de impozitare,
+Tax Rule Conflicts with {0},Conflicte normă fiscală cu {0},
+Tax Rule for transactions.,Regula de impozit pentru tranzacțiile.,
+Tax Template is mandatory.,Format de impozitare este obligatorie.,
+Tax Withholding rates to be applied on transactions.,Ratele de reținere fiscală aplicabile tranzacțiilor.,
+Tax template for buying transactions.,Șablon taxa pentru tranzacțiilor de cumpărare.,
+Tax template for item tax rates.,Model de impozitare pentru cote de impozit pe articole.,
+Tax template for selling transactions.,Șablon impozit pentru tranzacțiile de vânzare.,
+Taxable Amount,Sumă impozabilă,
+Taxes,Impozite,
+Team Updates,echipa Actualizări,
+Technology,Tehnologia nou-aparuta,
+Telecommunications,Telecomunicații,
+Telephone Expenses,Cheltuieli de telefon,
+Television,Televiziune,
+Template Name,Numele de șablon,
+Template of terms or contract.,Șablon de termeni sau contractului.,
+Templates of supplier scorecard criteria.,Șabloane ale criteriilor privind tabloul de bord al furnizorului.,
+Templates of supplier scorecard variables.,Șabloane ale variabilelor pentru scorurile pentru furnizori.,
+Templates of supplier standings.,Modele de clasificare a furnizorilor.,
+Temporarily on Hold,Temporar în așteptare,
+Temporary,Temporar,
+Temporary Accounts,Conturi temporare,
+Temporary Opening,Deschiderea temporară,
+Terms and Conditions,Termeni si conditii,
+Terms and Conditions Template,Termeni și condiții Format,
+Territory,Teritoriu,
+Test,Test,
+Thank you,Mulțumesc,
+Thank you for your business!,Vă mulțumesc pentru afacerea dvs!,
+The 'From Package No.' field must neither be empty nor it's value less than 1.,"&quot;Din pachetul nr.&quot; câmpul nu trebuie să fie nici gol, nici valoarea lui mai mică decât 1.",
+The Brand,Marca,
+The Item {0} cannot have Batch,Postul {0} nu poate avea Lot,
+The Loyalty Program isn't valid for the selected company,Programul de loialitate nu este valabil pentru compania selectată,
+The Payment Term at row {0} is possibly a duplicate.,"Termenul de plată la rândul {0} este, eventual, un duplicat.",
+The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Pe termen Data de încheiere nu poate fi mai devreme decât Start Termen Data. Vă rugăm să corectați datele și încercați din nou.,
+The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Pe termen Data de încheiere nu poate fi mai târziu de Anul Data de încheiere a anului universitar la care este legat termenul (anului universitar {}). Vă rugăm să corectați datele și încercați din nou.,
+The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Start Termen Data nu poate fi mai devreme decât data Anul de începere a anului universitar la care este legat termenul (anului universitar {}). Vă rugăm să corectați datele și încercați din nou.,
+The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Anul Data de încheiere nu poate fi mai devreme decât data An Start. Vă rugăm să corectați datele și încercați din nou.,
+The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,Valoarea {0} stabilită în această solicitare de plată este diferită de suma calculată a tuturor planurilor de plată: {1}. Asigurați-vă că este corect înainte de a trimite documentul.,
+The day(s) on which you are applying for leave are holidays. You need not apply for leave.,A doua zi (e) pe care se aplica pentru concediu sunt sărbători. Nu trebuie să se aplice pentru concediu.,
+The field From Shareholder cannot be blank,Câmpul From Shareholder nu poate fi gol,
+The field To Shareholder cannot be blank,Câmpul către acționar nu poate fi necompletat,
+The fields From Shareholder and To Shareholder cannot be blank,Câmpurile de la acționar și de la acționar nu pot fi goale,
+The folio numbers are not matching,Numerele folio nu se potrivesc,
+The holiday on {0} is not between From Date and To Date,Vacanta pe {0} nu este între De la data si pana in prezent,
+The name of the institute for which you are setting up this system.,Numele institutului pentru care configurați acest sistem.,
+The name of your company for which you are setting up this system.,Numele companiei dumneavoastră pentru care vă sunt configurarea acestui sistem.,
+The number of shares and the share numbers are inconsistent,Numărul de acțiuni și numerele de acțiuni sunt incoerente,
+The payment gateway account in plan {0} is different from the payment gateway account in this payment request,Contul gateway-ului de plată din plan {0} este diferit de contul gateway-ului de plată din această solicitare de plată,
+The selected BOMs are not for the same item,Cele BOM selectate nu sunt pentru același articol,
+The selected item cannot have Batch,Elementul selectat nu poate avea lot,
+The seller and the buyer cannot be the same,Vânzătorul și cumpărătorul nu pot fi aceleași,
+The shareholder does not belong to this company,Acționarul nu aparține acestei companii,
+The shares already exist,Acțiunile există deja,
+The shares don't exist with the {0},Acțiunile nu există cu {0},
+"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Sarcina a fost considerată ca o lucrare de fond. În cazul în care există vreo problemă cu privire la procesare în fundal, sistemul va adăuga un comentariu despre eroarea la această reconciliere a stocului și va reveni la etapa de proiectare.",
+"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 inconsistencies between the rate, no of shares and the amount calculated","Există neconcordanțe între rata, numărul de acțiuni și suma calculată",
+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 be multiple tiered collection factor based on the total spent. But the conversion factor for redemption will always be same for all the tier.,Pot exista un factor de colectare multiplu diferențiat bazat pe totalul cheltuit. Dar factorul de conversie pentru răscumpărare va fi întotdeauna același pentru toate nivelurile.,
+There can only be 1 Account per Company in {0} {1},Nu poate fi doar un cont per companie în {0} {1},
+"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 no leave period in between {0} and {1},Nu există o perioadă de concediu între {0} și {1},
+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 editat.,
+There isn't any item variant for the selected item,Nu există variante de elemente pentru elementul selectat,
+"There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.","Se pare că există o problemă cu configurația serverului GoCardless. Nu vă faceți griji, în caz de eșec, suma va fi rambursată în cont.",
+There were errors creating Course Schedule,Au apărut erori la crearea programului de curs,
+There were errors.,Au fost erori.,
+This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"Acest post este un șablon și nu pot fi folosite în tranzacții. Atribute articol vor fi copiate pe în variantele cu excepția cazului în este setat ""Nu Copy""",
+This Item is a Variant of {0} (Template).,Acest element este o variantă de {0} (șablon).,
+This Month's Summary,Rezumatul acestei luni,
+This Week's Summary,Rezumat această săptămână,
+This action will stop future billing. Are you sure you want to cancel this subscription?,Această acțiune va opri facturarea viitoare. Sigur doriți să anulați acest abonament?,
+This covers all scorecards tied to this Setup,Aceasta acoperă toate tabelele de scoruri legate de această configurație,
+This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Acest document este peste limita de {0} {1} pentru elementul {4}. Faci un alt {3} împotriva aceleași {2}?,
+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 department and cannot be edited.,Acesta este un departament rădăcină și nu poate fi editat.,
+This is a root healthcare service unit and cannot be edited.,Aceasta este o unitate de asistență medicală rădăcină și nu poate fi editată.,
+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 supplier group and cannot be edited.,Acesta este un grup de furnizori rădăcini și nu poate fi editat.,
+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 based on logs against this Vehicle. See timeline below for details,Aceasta se bazează pe bușteni împotriva acestui vehicul. A se vedea calendarul de mai jos pentru detalii,
+This is based on stock movement. See {0} for details,Aceasta se bazează pe mișcare stoc. A se vedea {0} pentru detalii,
+This is based on the Time Sheets created against this project,Aceasta se bazează pe fișele de pontaj create împotriva acestui proiect,
+This is based on the attendance of this Employee,Aceasta se bazează pe prezența a acestui angajat,
+This is based on the attendance of this Student,Aceasta se bazează pe prezența acestui student,
+This is based on transactions against this Customer. See timeline below for details,Aceasta se bazează pe tranzacțiile împotriva acestui client. A se vedea calendarul de mai jos pentru detalii,
+This is based on transactions against this Healthcare Practitioner.,Aceasta se bazează pe tranzacțiile împotriva acestui medic.,
+This is based on transactions against this Patient. See timeline below for details,Aceasta se bazează pe tranzacțiile împotriva acestui pacient. Consultați linia temporală de mai jos pentru detalii,
+This is based on transactions against this Sales Person. See timeline below for details,Aceasta se bazează pe tranzacțiile efectuate împotriva acestei persoane de vânzări. Consultați linia temporală de mai jos pentru detalii,
+This is based on transactions against this Supplier. See timeline below for details,Aceasta se bazează pe tranzacțiile împotriva acestui furnizor. A se vedea calendarul de mai jos pentru detalii,
+This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Aceasta va trimite salariile de salarizare și va crea înregistrarea de înregistrare în jurnal. Doriți să continuați?,
+This {0} conflicts with {1} for {2} {3},Acest {0} conflicte cu {1} pentru {2} {3},
+Time Sheet for manufacturing.,Fișa de timp pentru fabricație.,
+Time Tracking,Urmărirea timpului,
+"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Slotul de timp a fost anulat, slotul {0} până la {1} suprapune slotul existent {2} până la {3}",
+Time slots added,Au fost adăugate sloturi de timp,
+Time(in mins),Timp (în min),
+Timer,Cronometrul,
+Timer exceeded the given hours.,Timerul a depășit orele date.,
+Timesheet,Pontaj,
+Timesheet for tasks.,Timesheet pentru sarcini.,
+Timesheet {0} is already completed or cancelled,Pontajul {0} este deja finalizat sau anulat,
+Timesheets,pontaje,
+"Timesheets help keep track of time, cost and billing for activites done by your team","Pontaje ajuta să urmăriți timp, costuri și de facturare pentru activitati efectuate de echipa ta",
+Titles for print templates e.g. Proforma Invoice.,"Titluri de șabloane de imprimare, de exemplu proforma Factura.",
+To,La,
+To Address 1,Pentru a adresa 1,
+To Address 2,Pentru a adresa 2,
+To Bill,Pentru a Bill,
+To Date,La Data,
+To Date cannot be before From Date,Până în prezent nu poate fi înainte de data,
+To Date cannot be less than From Date,Data nu poate fi mai mică decât Din data,
+To Date must be greater than From Date,Pentru data trebuie să fie mai mare decât de la data,
+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 Datetime,Pentru a Datetime,
+To Deliver,A livra,
+To Deliver and Bill,Pentru a livra și Bill,
+To Fiscal Year,Anul fiscal,
+To GSTIN,Pentru GSTIN,
+To Party Name,La numele partidului,
+To Pin Code,Pentru a activa codul,
+To Place,A plasa,
+To Receive,A primi,
+To Receive and Bill,Pentru a primi și Bill,
+To State,A afirma,
+To Warehouse,La Depozit,
+To create a Payment Request reference document is required,Pentru a crea un document de referință privind solicitarea de plată este necesar,
+To date can not be equal or less than from date,Până în prezent nu poate fi egală sau mai mică decât de la data,
+To date can not be less than from date,Până în prezent nu poate fi mai mică decât de la data,
+To date can not greater than employee's relieving date,Până în prezent nu poate fi mai mare decât data scutirii angajatului,
+"To filter based on Party, select Party Type first","Pentru a filtra pe baza Party, selectați Party Tip primul",
+"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Pentru a obține cele mai bune din ERPNext, vă recomandăm să luați ceva timp și de ceas aceste filme de ajutor.",
+"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 make Customer based incentive schemes.,Pentru a crea scheme de stimulare bazate pe client.,
+"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 view logs of Loyalty Points assigned to a Customer.,Pentru a vizualiza jurnalele punctelor de loialitate atribuite unui client.,
+To {0},Pentru a {0},
+To {0} | {1} {2},Pentru a {0} | {1} {2},
+Toggle Filters,Comutați filtrele,
+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,Instrumente,
+Total (Credit),Total (Credit),
+Total (Without Tax),Total (fără taxe),
+Total Absent,Raport Absent,
+Total Achieved,Raport Realizat,
+Total Actual,Raport real,
+Total Allocated Leaves,Frunzele totale alocate,
+Total Amount,Suma totală,
+Total Amount Credited,Suma totală creditată,
+Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Taxe totale aplicabile în tabelul de achiziție Chitanță Elementele trebuie să fie la fel ca total impozite și taxe,
+Total Budget,Buget total,
+Total Collected: {0},Totalul colectat: {0},
+Total Commission,Total de Comisie,
+Total Contribution Amount: {0},Suma totală a contribuției: {0},
+Total Credit/ Debit Amount should be same as linked Journal Entry,Suma totală a creditului / debitului ar trebui să fie aceeași cu cea înregistrată în jurnal,
+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 Invoiced Amount,Suma totală facturată,
+Total Leaves,Frunze totale,
+Total Order Considered,Comanda total Considerat,
+Total Order Value,Valoarea totală Comanda,
+Total Outgoing,Raport de ieșire,
+Total Outstanding,Total deosebit,
+Total Outstanding Amount,Total Suma Impresionant,
+Total Outstanding: {0},Total excepție: {0},
+Total Paid Amount,Total Suma plătită,
+Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Suma totală de plată în Planul de Plăți trebuie să fie egală cu Total / Rotunjit,
+Total Payments,Total plăți,
+Total Present,Raport Prezent,
+Total Qty,Raport Cantitate,
+Total Quantity,Cantitatea totala,
+Total Revenue,Raport Venituri,
+Total Student,Student total,
+Total Target,Raport țintă,
+Total Tax,Taxa totală,
+Total Taxable Amount,Sumă impozabilă totală,
+Total Taxable Value,Valoarea impozabilă totală,
+Total Unpaid: {0},Neremunerat totală: {0},
+Total Variance,Raport Variance,
+Total Weightage of all Assessment Criteria must be 100%,Weightage totală a tuturor criteriilor de evaluare trebuie să fie 100%,
+Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),avans total ({0}) împotriva Comanda {1} nu poate fi mai mare decât totalul ({2}),
+Total advance amount cannot be greater than total claimed amount,Suma avansului total nu poate fi mai mare decât suma totală revendicată,
+Total advance amount cannot be greater than total sanctioned amount,Suma avansului total nu poate fi mai mare decât suma totală sancționată,
+Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,Frunzele totale alocate sunt mai multe zile decât alocarea maximă a tipului de concediu {0} pentru angajatul {1} în perioada respectivă,
+Total allocated leaves are more than days in the period,TOTAL frunze alocate sunt mai mult decât zile în perioada,
+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 cannot be zero,Totalul nu poate să fie zero,
+Total contribution percentage should be equal to 100,Procentul total al contribuției ar trebui să fie egal cu 100,
+Total flexible benefit component amount {0} should not be less than max benefits {1},Suma totală a componentelor de beneficii flexibile {0} nu trebuie să fie mai mică decât beneficiile maxime {1},
+Total hours: {0},Numărul total de ore: {0},
+Total leaves allocated is mandatory for Leave Type {0},Numărul total de frunze alocate este obligatoriu pentru Type Leave {0},
+Total working hours should not be greater than max working hours {0},Numărul total de ore de lucru nu trebuie sa fie mai mare de ore de lucru max {0},
+Total {0} ({1}),Total {0} ({1}),
+"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Total {0} pentru toate articolele este zero, poate fi ar trebui să schimbați „Distribuirea cheltuielilor pe baza“",
+Total(Amt),Total (Amt),
+Total(Qty),Total (Cantitate),
+Traceability,Trasabilitate,
+Traceback,Traceback,
+Track Leads by Lead Source.,Urmărește Oportunități după Sursă Oportunitate,
+Training,Pregătire,
+Training Event,Eveniment de formare,
+Training Events,Evenimente de instruire,
+Training Feedback,Feedback formare,
+Training Result,Rezultatul de formare,
+Transaction,Tranzacţie,
+Transaction Date,Data tranzacției,
+Transaction Type,tipul tranzacției,
+Transaction currency must be same as Payment Gateway currency,Moneda de tranzacție trebuie să fie aceeași ca și de plată Gateway monedă,
+Transaction not allowed against stopped Work Order {0},Tranzacția nu este permisă împotriva comenzii de lucru oprita {0},
+Transaction reference no {0} dated {1},de referință al tranzacției nu {0} {1} din,
+Transactions,tranzacţii,
+Transactions can only be deleted by the creator of the Company,Tranzacții pot fi șterse doar de către creatorul Companiei,
+Transfer,Transfer,
+Transfer Material,Material de transfer,
+Transfer Type,Tip de transfer,
+Transfer an asset from one warehouse to another,Se transferă un activ de la un depozit la altul,
+Transfered,transferat,
+Transferred Quantity,Cantitate transferată,
+Transport Receipt Date,Data primirii transportului,
+Transport Receipt No,Primirea transportului nr,
+Transportation,Transport,
+Transporter ID,ID-ul transportatorului,
+Transporter Name,Transporter Nume,
+Travel,Călători,
+Travel Expenses,Cheltuieli de calatorie,
+Tree Type,Arbore Tip,
+Tree of Bill of Materials,Arborele de Bill de materiale,
+Tree of Item Groups.,Arborele de Postul grupuri.,
+Tree of Procedures,Arborele procedurilor,
+Tree of Quality Procedures.,Arborele procedurilor de calitate.,
+Tree of financial Cost Centers.,Tree of centre de cost financiare.,
+Tree of financial accounts.,Arborescentă conturilor financiare.,
+Treshold {0}% appears more than once,Treshold {0}% apare mai mult decât o dată,
+Trial Period End Date Cannot be before Trial Period Start Date,Perioada de încheiere a perioadei de încercare nu poate fi înainte de data începerii perioadei de încercare,
+Trialling,experimentării,
+Type of Business,Tip de afacere,
+Types of activities for Time Logs,Tipuri de activități pentru busteni Timp,
+UOM,UOM,
+UOM Conversion factor is required in row {0},Factor UOM de conversie este necesară în rândul {0},
+UOM coversion factor required for UOM: {0} in Item: {1},Factor coversion UOM UOM necesare pentru: {0} in articol: {1},
+URL,URL-ul,
+Unable to find DocType {0},Nu se poate găsi DocType {0},
+Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Imposibil de găsit rata de schimb pentru {0} până la {1} pentru data cheie {2}. Creați manual un registru de schimb valutar,
+Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Nu se poate găsi scorul începând cu {0}. Trebuie să aveți scoruri în picioare care acoperă între 0 și 100,
+Unable to find variable: ,Imposibil de găsit variabila:,
+Unblock Invoice,Deblocați factura,
+Uncheck all,Deselecteaza tot,
+Unclosed Fiscal Years Profit / Loss (Credit),Unclosed fiscal Ani de Profit / Pierdere (credit),
+Unit,Unitate,
+Unit of Measure,Unitate 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,
+Unknown,Necunoscut,
+Unpaid,Neachitat,
+Unsecured Loans,Creditele negarantate,
+Unsubscribe from this Email Digest,Dezabona de la acest e-mail Digest,
+Unsubscribed,Nesubscrise,
+Until,Până la,
+Unverified Webhook Data,Datele Webhook neconfirmate,
+Update Account Name / Number,Actualizați numele / numărul contului,
+Update Account Number / Name,Actualizați numărul / numele contului,
+Update Cost,Actualizare Cost,
+Update Items,Actualizați elementele,
+Update Print Format,Actualizare Format Print,
+Update Response,Actualizați răspunsul,
+Update bank payment dates with journals.,Actualizați datele de plată bancar cu reviste.,
+Update in progress. It might take a while.,Actualizare în curs. Ar putea dura ceva timp.,
+Update rate as per last purchase,Rata de actualizare ca pe ultima achiziție,
+Update stock must be enable for the purchase invoice {0},Actualizați stocul trebuie să fie activat pentru factura de achiziție {0},
+Updating Variants...,Actualizarea variantelor ...,
+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,
+Use Sandbox,utilizare Sandbox,
+Used Leaves,Frunze utilizate,
+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 Remark,Observație utilizator,
+User has not applied rule on the invoice {0},Utilizatorul nu a aplicat o regulă pentru factură {0},
+User {0} already exists,Utilizatorul {0} există deja,
+User {0} created,Utilizatorul {0} a fost creat,
+User {0} does not exist,Utilizatorul {0} nu există,
+User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Utilizatorul {0} nu are niciun POS profil implicit. Verificați implicit la Rând {1} pentru acest utilizator.,
+User {0} is already assigned to Employee {1},Utilizatorul {0} este deja alocat Angajat {1},
+User {0} is already assigned to Healthcare Practitioner {1},Utilizatorul {0} este deja însărcinat cu medicul de îngrijire medicală {1},
+Users,Utilizatori,
+Utility Expenses,Cheltuieli de utilitate,
+Valid From Date must be lesser than Valid Upto Date.,Valabil din data trebuie să fie mai mică decât valabil până la data.,
+Valid Till,Valabil până la,
+Valid from and valid upto fields are mandatory for the cumulative,Câmpurile valabile și valabile până la acestea sunt obligatorii pentru cumul,
+Valid from date must be less than valid upto date,Valabil de la data trebuie să fie mai mic decât valabil până la data actuală,
+Valid till date cannot be before transaction date,Valabil până la data nu poate fi înainte de data tranzacției,
+Validity,Valabilitate,
+Validity period of this quotation has ended.,Perioada de valabilitate a acestui citat sa încheiat.,
+Valuation Rate,Rata de evaluare,
+Valuation Rate is mandatory if Opening Stock entered,Evaluarea Rata este obligatorie în cazul în care a intrat Deschiderea stoc,
+Valuation type charges can not marked as Inclusive,Taxele de tip evaluare nu poate marcate ca Inclusive,
+Value Or Qty,Valoare sau Cantitate,
+Value Proposition,Propunere de valoare,
+Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Valoare pentru atributul {0} trebuie să fie în intervalul de {1} la {2} în trepte de {3} pentru postul {4},
+Value missing,Valoarea lipsește,
+Value must be between {0} and {1},Valoarea trebuie să fie între {0} și {1},
+"Values of exempt, nil rated and non-GST inward supplies","Valorile livrărilor interne scutite, nule și fără GST",
+Variable,Variabil,
+Variance,variație,
+Variance ({}),Varianță ({}),
+Variant,Variantă,
+Variant Attributes,Atribute Variant,
+Variant Based On cannot be changed,Varianta bazată pe nu poate fi modificată,
+Variant Details Report,Varianta Detalii raport,
+Variant creation has been queued.,Crearea de variante a fost în coada de așteptare.,
+Vehicle Expenses,Cheltuielile pentru vehicule,
+Vehicle No,Vehicul Nici,
+Vehicle Type,Tip de vehicul,
+Vehicle/Bus Number,Numărul vehiculului / autobuzului,
+Venture Capital,Capital de risc,
+View Chart of Accounts,Vezi Diagramă de Conturi,
+View Fees Records,Vizualizați înregistrările de taxe,
+View Form,Formular de vizualizare,
+View Lab Tests,Vizualizați testele de laborator,
+View Leads,Vezi Piste,
+View Ledger,Vezi Registru Contabil,
+View Now,Vizualizează acum,
+View a list of all the help videos,Vizualizați o listă cu toate filmele de ajutor,
+View in Cart,Vizualizare Coș,
+Visit report for maintenance call.,Vizitați raport pentru apel de mentenanță.,
+Visit the forums,Vizitați forumurile,
+Vital Signs,Semnele vitale,
+Volunteer,Voluntar,
+Volunteer Type information.,Informații de tip Voluntar.,
+Volunteer information.,Informații despre voluntari.,
+Voucher #,Voucher #,
+Voucher No,Voletul nr,
+Voucher Type,Tip Voucher,
+WIP Warehouse,WIP Depozit,
+Walk In,Walk In,
+Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Depozitul nu poate fi șters deoarece există intrări in registru contabil stocuri pentru acest depozit.,
+Warehouse cannot be changed for Serial No.,Depozit nu poate fi schimbat pentru Serial No.,
+Warehouse is mandatory,Depozitul este obligatoriu,
+Warehouse is mandatory for stock Item {0} in row {1},Depozitul este obligatoriu pentru articol stoc {0} în rândul {1},
+Warehouse not found in the system,Depozit nu a fost găsit în sistemul,
+"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}","Depozitul necesar la rândul nr. {0}, vă rugăm să setați un depozit implicit pentru elementul {1} pentru companie {2}",
+Warehouse required for stock Item {0},Depozit necesar pentru stoc articol {0},
+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,Depozitul {0} nu există,
+"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Warehouse {0} nu este conectat la niciun cont, menționați contul din înregistrarea din depozit sau setați contul de inventar implicit din compania {1}.",
+Warehouses with child nodes cannot be converted to ledger,Depozitele cu noduri copil nu pot fi convertite în registru contabil,
+Warehouses with existing transaction can not be converted to group.,Depozite tranzacție existente nu pot fi convertite în grup.,
+Warehouses with existing transaction can not be converted to ledger.,Depozitele cu tranzacții existente nu pot fi convertite în registru contabil.,
+Warning,Avertisment,
+Warning: Another {0} # {1} exists against stock entry {2},Atenție: Un alt {0} # {1} există împotriva intrării stoc {2},
+Warning: Invalid SSL certificate on attachment {0},Atenție: certificat SSL invalid pe atașament {0},
+Warning: Invalid attachment {0},Atenție: Attachment invalid {0},
+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 Customer's Purchase Order {1},Atenție: comandă de vânzări {0} există deja împotriva Ordinului de Procurare clientului {1},
+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,garanţie,
+Warranty Claim,Garanție revendicarea,
+Warranty Claim against Serial No.,Garantie revendicarea împotriva Serial No.,
+Website,Site web,
+Website Image should be a public file or website URL,Site-ul Image ar trebui să fie un fișier public sau site-ul URL-ul,
+Website Image {0} attached to Item {1} cannot be found,Site-ul Image {0} atașat la postul {1} nu poate fi găsit,
+Website Listing,Înregistrarea site-ului,
+Website Manager,Site-ul Manager de,
+Website Settings,Setarile site-ului,
+Wednesday,Miercuri,
+Week,Săptămână,
+Weekdays,Zilele saptamanii,
+Weekly,Săptămânal,
+Welcome email sent,E-mailul de bun venit a fost trimis,
+Welcome to ERPNext,Bine ati venit la ERPNext,
+What do you need help with?,La ce ai nevoie de ajutor?,
+What does it do?,Ce face?,
+Where manufacturing operations are carried.,În cazul în care operațiunile de fabricație sunt efectuate.,
+White,alb,
+Wire Transfer,Transfer,
+WooCommerce Products,Produse WooCommerce,
+Work In Progress,Lucrări în curs,
+Work Order,Comandă de lucru,
+Work Order already created for all items with BOM,Ordin de lucru deja creat pentru toate articolele cu BOM,
+Work Order cannot be raised against a Item Template,Ordinul de lucru nu poate fi ridicat împotriva unui șablon de element,
+Work Order has been {0},Ordinul de lucru a fost {0},
+Work Order not created,Ordinul de lucru nu a fost creat,
+Work Order {0} must be cancelled before cancelling this Sales Order,Ordinul de lucru {0} trebuie anulat înainte de a anula acest ordin de vânzări,
+Work Order {0} must be submitted,Ordinul de lucru {0} trebuie trimis,
+Work Orders Created: {0},Comenzi de lucru create: {0},
+Work Summary for {0},Rezumat Lucrare pentru {0},
+Work-in-Progress Warehouse is required before Submit,De lucru-in-Progress Warehouse este necesară înainte Trimite,
+Workflow,Flux de lucru,
+Working,De lucru,
+Working Hours,Ore de lucru,
+Workstation,Stație de lucru,
+Workstation is closed on the following dates as per Holiday List: {0},Workstation este închis la următoarele date ca pe lista de vacanta: {0},
+Wrapping up,Înfășurați-vă,
+Wrong Password,Parola gresita,
+Year start date or end date is overlapping with {0}. To avoid please set company,Anul Data de începere sau de încheiere este suprapunerea cu {0}. Pentru a evita vă rugăm să setați companie,
+You are not authorized to add or update entries before {0},Nu ești autorizat să adăugi sau să actualizezi intrări înainte de {0},
+You are not authorized to approve leaves on Block Dates,Tu nu sunt autorizate să aprobe frunze pe bloc Perioada,
+You are not authorized to set Frozen value,Nu esti autorizat pentru a configura valoarea Congelat,
+You are not present all day(s) between compensatory leave request days,Nu vă prezentați toată ziua (zilele) între zilele de solicitare a plății compensatorii,
+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 current voucher in 'Against Journal Entry' column,"Nu puteți introduce voucher curent în ""Împotriva Jurnalul intrare"" coloană",
+You can only have Plans with the same billing cycle in a Subscription,Puteți avea numai planuri cu același ciclu de facturare într-un abonament,
+You can only redeem max {0} points in this order.,Puteți răscumpăra maxim {0} puncte în această ordine.,
+You can only renew if your membership expires within 30 days,Puteți reînnoi numai dacă expirați în termen de 30 de zile,
+You can only select a maximum of one option from the list of check boxes.,Puteți selecta numai o singură opțiune din lista de casete de selectare.,
+You can only submit Leave Encashment for a valid encashment amount,Puteți să trimiteți numai permisiunea de înregistrare pentru o sumă validă de încasare,
+You can't redeem Loyalty Points having more value than the Grand Total.,Nu puteți valorifica punctele de loialitate cu valoare mai mare decât suma totală.,
+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 cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Nu puteți șterge Anul fiscal {0}. Anul fiscal {0} este setat ca implicit în Setări globale,
+You cannot delete Project Type 'External',Nu puteți șterge tipul de proiect &quot;extern&quot;,
+You cannot edit root node.,Nu puteți edita nodul rădăcină.,
+You cannot restart a Subscription that is not cancelled.,Nu puteți reporni o abonament care nu este anulat.,
+You don't have enought Loyalty Points to redeem,Nu aveți puncte de loialitate pentru a răscumpăra,
+You have already assessed for the assessment criteria {}.,Ați evaluat deja criteriile de evaluare {}.,
+You have already selected items from {0} {1},Ați selectat deja un produs de la {0} {1},
+You have been invited to collaborate on the project: {0},Ați fost invitat să colaboreze la proiect: {0},
+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 need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,Trebuie să fii alt utilizator decât Administrator cu rolul managerului de sistem și al Managerului de articole pentru a te înregistra pe Marketplace.,
+You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,Trebuie să fii un utilizator cu roluri de manager de sistem și manager de articole pentru a adăuga utilizatori la Marketplace.,
+You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Trebuie să fiți utilizator cu funcții Manager Manager și Manager de posturi pentru a vă înregistra pe Marketplace.,
+You need to be logged in to access this page,Trebuie să fii conectat pentru a putea accesa această pagină,
+You need to enable Shopping Cart,Trebuie să activați Coșul de cumpărături,
+You will lose records of previously generated invoices. Are you sure you want to restart this subscription?,Veți pierde înregistrări ale facturilor generate anterior. Sigur doriți să reporniți acest abonament?,
+Your Organization,Organizația dumneavoastră,
+Your cart is Empty,Coșul dvs. este gol,
+Your email address...,Adresa ta de email...,
+Your order is out for delivery!,Comanda dvs. este livrată!,
+Your tickets,Biletele tale,
+ZIP Code,Cod postal,
+[Error],[Eroare],
+[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Forma / Postul / {0}) este din stoc,
+`Freeze Stocks Older Than` should be smaller than %d days.,'Blochează stocuri mai vechi decât' ar trebui să fie mai mic de %d zile.,
+based_on,bazat pe,
+cannot be greater than 100,nu poate fi mai mare de 100,
+disabled user,utilizator dezactivat,
+"e.g. ""Build tools for builders""","de exemplu ""Construi instrumente de constructori """,
+"e.g. ""Primary School"" or ""University""","de exemplu, &quot;Școala primară&quot; sau &quot;Universitatea&quot;",
+"e.g. Bank, Cash, Credit Card","de exemplu, bancar, Cash, Card de credit",
+hidden,ascuns,
+modified,modificată,
+old_parent,old_parent,
+on,Pornit,
+{0} '{1}' is disabled,{0} '{1}' este dezactivat,
+{0} '{1}' not in Fiscal Year {2},{0} '{1}' nu există în anul fiscal {2},
+{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) nu poate fi mai mare decât cantitatea planificată ({2}) din Ordinul de Lucru {3},
+{0} - {1} is inactive student,{0} - {1} este elev inactiv,
+{0} - {1} is not enrolled in the Batch {2},{0} - {1} nu este înscris în lotul {2},
+{0} - {1} is not enrolled in the Course {2},{0} - {1} nu este înscris la Cursul {2},
+{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},Bugetul {0} pentru Contul {1} față de {2} {3} este {4}. Acesta este depășit cu {5},
+{0} Digest,{0} Digest,
+{0} Request for {1},{0} Cerere pentru {1},
+{0} Result submittted,{0} Rezultat transmis,
+{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} numere de serie necesare pentru postul {1}. Ați furnizat {2}.,
+{0} Student Groups created.,{0} Grupurile de elevi au fost create.,
+{0} Students have been enrolled,{0} Elevii au fost înscriși,
+{0} against Bill {1} dated {2},{0} comparativ cu factura {1} din data de {2},
+{0} against Purchase Order {1},{0} comparativ cu comanda de cumpărare {1},
+{0} against Sales Invoice {1},{0} comparativ cu factura de vânzări {1},
+{0} against Sales Order {1},{0} comparativ cu comanda de vânzări {1},
+{0} already allocated for Employee {1} for period {2} to {3},{0} deja alocate pentru Angajatul {1} pentru perioada {2} - {3},
+{0} applicable after {1} working days,{0} aplicabil după {1} zile lucrătoare,
+{0} asset cannot be transferred,{0} activul nu poate fi transferat,
+{0} can not be negative,{0} nu poate fi negativ,
+{0} created,{0} creat,
+"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.","{0} are în prezent {1} Scor de Furnizor, iar comenzile de achiziție catre acest furnizor ar trebui emise cu prudență.",
+"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.","{0} are în prezent {1} Scor de Furnizor, iar cererile de oferta către acest furnizor ar trebui emise cu prudență.",
+{0} does not belong to Company {1},{0} nu aparține Companiei {1},
+{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0} nu are un program de practicieni în domeniul sănătății. Adăugați-o la medicul de masterat în domeniul sănătății,
+{0} entered twice in Item Tax,{0} a fost introdus de două ori în taxa articolului,
+{0} for {1},{0} pentru {1},
+{0} has been submitted successfully,{0} a fost trimis cu succes,
+{0} has fee validity till {1},{0} are valabilitate până la data de {1},
+{0} hours,{0} ore,
+{0} in row {1},{0} în rândul {1},
+{0} is blocked so this transaction cannot proceed,"{0} este blocat, astfel încât această tranzacție nu poate continua",
+{0} is mandatory,{0} este obligatoriu,
+{0} is mandatory for Item {1},{0} este obligatoriu pentru articolul {1},
+{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} este obligatoriu. Este posibil ca înregistrarea schimbului valutar nu este creată pentru {1} până la {2}.,
+{0} is not a stock Item,{0} nu este un articol de stoc,
+{0} is not a valid Batch Number for Item {1},{0} nu este un număr de lot valid aferent articolului {1},
+{0} is not added in the table,{0} nu este adăugat în tabel,
+{0} is not in Optional Holiday List,{0} nu este în lista de sărbători opționale,
+{0} is not in a valid Payroll Period,{0} nu este într-o Perioadă de Salarizare validă,
+{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} este acum anul fiscal implicit. Vă rugăm să reîmprospătați browser-ul dvs. pentru ca modificarea să aibă efect.,
+{0} is on hold till {1},{0} este în așteptare până la {1},
+{0} item found.,{0} element găsit.,
+{0} items found.,{0} articole găsite.,
+{0} items in progress,{0} elemente în curs,
+{0} items produced,{0} articole produse,
+{0} must appear only once,{0} trebuie să apară doar o singură dată,
+{0} must be negative in return document,{0} trebuie să fie negativ în documentul de retur,
+{0} must be submitted,{0} trebuie transmis,
+{0} not allowed to transact with {1}. Please change the Company.,{0} nu este permis să efectueze tranzacții cu {1}. Vă rugăm să schimbați compania selectată.,
+{0} not found for item {1},{0} nu a fost găsit pentru articolul {1},
+{0} parameter is invalid,Parametrul {0} este nevalid,
+{0} payment entries can not be filtered by {1},{0} înregistrări de plată nu pot fi filtrate de {1},
+{0} should be a value between 0 and 100,{0} ar trebui să fie o valoare cuprinsă între 0 și 100,
+{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} unități de [{1}] (# Forma / Postul / {1}) găsit în [{2}] (# Forma / Depozit / {2}),
+{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} unități de {1} necesare în {2} pe {3} {4} pentru {5} pentru a finaliza această tranzacție.,
+{0} units of {1} needed in {2} to complete this transaction.,{0} unități de {1} necesare în {2} pentru a finaliza această tranzacție.,
+{0} valid serial nos for Item {1},{0} numere de serie valabile pentru articolul {1},
+{0} variants created.,{0} variante create.,
+{0} {1} created,{0} {1} creat,
+{0} {1} does not exist,{0} {1} nu există,
+{0} {1} has been modified. Please refresh.,{0} {1} a fost modificat. Vă rugăm să reîmprospătați.,
+{0} {1} has not been submitted so the action cannot be completed,"{0} {1} nu a fost transmis, astfel încât acțiunea nu poate fi finalizată",
+"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} este asociat cu {2}, dar contul de partid este {3}",
+{0} {1} is cancelled or closed,{0} {1} este anulat sau închis,
+{0} {1} is cancelled or stopped,{0} {1} este anulată sau oprită,
+{0} {1} is cancelled so the action cannot be completed,"{0} {1} este anulată, astfel încât acțiunea nu poate fi terminată",
+{0} {1} is closed,{0} {1} este închis,
+{0} {1} is disabled,{0} {1} este dezactivat,
+{0} {1} is frozen,{0} {1} este blocat,
+{0} {1} is fully billed,{0} {1} este complet facturat,
+{0} {1} is not active,{0} {1} nu este activ,
+{0} {1} is not associated with {2} {3},{0} {1} nu este asociat cu {2} {3},
+{0} {1} is not present in the parent company,{0} {1} nu este prezentă în compania mamă,
+{0} {1} is not submitted,{0} {1} nu este introdus,
+{0} {1} is {2},{0} {1} este {2},
+{0} {1} must be submitted,{0} {1} trebuie să fie introdus,
+{0} {1} not in any active Fiscal Year.,{0} {1} nu se gaseste in niciun an fiscal activ.,
+{0} {1} status is {2},{0} {1} statusul este {2},
+{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: &quot;profit și pierdere&quot; cont de tip {2} nu este permisă în orificiul de intrare,
+{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Cont {2} nu aparține Companiei {3},
+{0} {1}: Account {2} is inactive,{0} {1}: Cont {2} este inactiv,
+{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Intrarea contabila {2} poate fi făcută numai în moneda: {3},
+{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: 아이템 {2} 는 Cost Center가  필수임,
+{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,{0} {1}: Centru de cost este necesară pentru &quot;profit și pierdere&quot; cont de {2}. Vă rugăm să configurați un centru de cost implicit pentru companie.,
+{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Cost Center {2} nu aparține Companiei {3},
+{0} {1}: Customer is required against Receivable account {2},{0} {1}: Clientul este necesară împotriva contului Receivable {2},
+{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Fie valoarea creditului de debit sau creditul sunt necesare pentru {2},
+{0} {1}: Supplier is required against Payable account {2},{0} {1}: Furnizorul este necesar pentru Contul de plăți {2},
+{0}% Billed,{0}% facturat,
+{0}% Delivered,{0}% livrat,
+"{0}: Employee email not found, hence email not sent","{0}: E-mail-ul angajatului nu a fost găsit, prin urmare, nu a fost trimis mail",
+{0}: From {0} of type {1},{0}: de la {0} de tipul {1},
+{0}: From {1},{0}: De la {1},
+{0}: {1} does not exists,{0}: {1} nu există,
+{0}: {1} not found in Invoice Details table,{0}: {1} nu a fost găsit în tabelul Detalii factură,
+{} of {},{} de {},
+Assigned To,Atribuit pentru,
+Chat,Chat,
+Completed By,Completat De,
+Conditions,Condiții,
+County,județ,
+Day of Week,Zi a săptămânii,
+"Dear System Manager,","Dragă System Manager,",
+Default Value,Valoare implicită,
+Email Group,E-mail grup,
+Email Settings,Setări e-mail,
+Email not sent to {0} (unsubscribed / disabled),Nu e-mail trimis la {0} (nesubscrise / dezactivat),
+Error Message,Mesaj de eroare,
+Fieldtype,Tip câmp,
+Help Articles,Articole de ajutor,
+ID,ID-ul,
+Images,Imagini,
+Import,Importarea,
+Language,Limba,
+Likes,Au apreciat,
+Merge with existing,Merge cu existente,
+Office,Birou,
+Orientation,Orientare,
+Parent,Mamă,
+Passive,Pasiv,
+Payment Failed,Plata esuata,
+Percent,La sută,
+Permanent,Permanent,
+Personal,Trader,
+Plant,Instalarea,
+Post,Publică,
+Postal,Poștal,
+Postal Code,Cod poștal,
+Previous,Precedenta,
+Provider,Furnizor de,
+Read Only,Doar Citire,
+Recipient,Destinatar,
+Reviews,opinii,
+Sender,Expeditor,
+Shop,Magazin,
+Subsidiary,Filială,
+There is some problem with the file url: {0},Există unele probleme cu URL-ul fișierului: {0},
+There were errors while sending email. Please try again.,Au fost erori în timp ce trimiterea de e-mail. Încercaţi din nou.,
+Values Changed,valori schimbată,
+or,sau,
+Ageing Range 4,Intervalul de îmbătrânire 4,
+Allocated amount cannot be greater than unadjusted amount,Suma alocată nu poate fi mai mare decât suma nejustificată,
+Allocated amount cannot be negative,Suma alocată nu poate fi negativă,
+"Difference Account must be a Asset/Liability type account, since this Stock Entry is an Opening Entry","Contul de diferență trebuie să fie un cont de tip Active / Răspundere, deoarece această intrare de stoc este o intrare de deschidere",
+Error in some rows,Eroare în unele rânduri,
+Import Successful,Import de succes,
+Please save first,Vă rugăm să salvați mai întâi,
+Price not found for item {0} in price list {1},Preț care nu a fost găsit pentru articolul {0} din lista de prețuri {1},
+Warehouse Type,Tip depozit,
+'Date' is required,„Data” este necesară,
+Benefit,Beneficiu,
+Budgets,Bugete,
+Bundle Qty,Cantitate de pachet,
+Company GSTIN,Compania GSTIN,
+Company field is required,Câmpul companiei este obligatoriu,
+Creating Dimensions...,Crearea dimensiunilor ...,
+Duplicate entry against the item code {0} and manufacturer {1},Duplică intrarea în codul articolului {0} și producătorul {1},
+Invalid GSTIN! The input you've entered doesn't match the GSTIN format for UIN Holders or Non-Resident OIDAR Service Providers,GSTIN nevalid! Intrarea introdusă nu se potrivește cu formatul GSTIN pentru deținătorii de UIN sau furnizorii de servicii OIDAR nerezidenți,
+Invoice Grand Total,Total factură mare,
+Last carbon check date cannot be a future date,Ultima dată de verificare a carbonului nu poate fi o dată viitoare,
+Make Stock Entry,Faceți intrarea în stoc,
+Quality Feedback,Feedback de calitate,
+Quality Feedback Template,Șablon de feedback de calitate,
+Rules for applying different promotional schemes.,Reguli pentru aplicarea diferitelor scheme promoționale.,
+Shift,Schimb,
+Show {0},Afișați {0},
+"Special Characters except '-', '#', '.', '/', '{{' and '}}' not allowed in naming series {0}","Caractere speciale, cu excepția &quot;-&quot;, &quot;#&quot;, &quot;.&quot;, &quot;/&quot;, &quot;{{&quot; Și &quot;}}&quot; nu sunt permise în numirea seriei {0}",
+Target Details,Detalii despre țintă,
+{0} already has a Parent Procedure {1}.,{0} are deja o procedură părinte {1}.,
+API,API-ul,
+Annual,Anual,
+Approved,Aprobat,
+Change,Schimbă,
+Contact Email,Email Persoana de Contact,
+Export Type,Tipul de export,
+From Date,Din data,
+Group By,A se grupa cu,
+Importing {0} of {1},Importarea {0} din {1},
+Invalid URL,URL invalid,
+Landscape,Peisaj,
+Last Sync On,Ultima sincronizare activată,
+Naming Series,Naming Series,
+No data to export,Nu există date de exportat,
+Portrait,Portret,
+Print Heading,Imprimare Titlu,
+Scheduler Inactive,Planificator inactiv,
+Scheduler is inactive. Cannot import data.,Planificatorul este inactiv. Nu se pot importa date.,
+Show Document,Afișează documentul,
+Show Traceback,Afișare Traceback,
+Video,Video,
+Webhook Secret,Secret Webhook,
+% Of Grand Total,% Din totalul mare,
+'employee_field_value' and 'timestamp' are required.,„angajat_field_value” și „timestamp” sunt obligatorii.,
+<b>Company</b> is a mandatory filter.,<b>Compania</b> este un filtru obligatoriu.,
+<b>From Date</b> is a mandatory filter.,<b>De la Date</b> este un filtru obligatoriu.,
+<b>From Time</b> cannot be later than <b>To Time</b> for {0},<b>From Time</b> nu poate fi mai târziu decât <b>To Time</b> pentru {0},
+<b>To Date</b> is a mandatory filter.,<b>Până în prezent</b> este un filtru obligatoriu.,
+A new appointment has been created for you with {0},O nouă programare a fost creată pentru dvs. cu {0},
+Account Value,Valoarea contului,
+Account is mandatory to get payment entries,Contul este obligatoriu pentru a obține înregistrări de plată,
+Account is not set for the dashboard chart {0},Contul nu este setat pentru graficul de bord {0},
+Account {0} does not belong to company {1},Contul {0} nu aparține companiei {1},
+Account {0} does not exists in the dashboard chart {1},Contul {0} nu există în graficul de bord {1},
+Account: <b>{0}</b> is capital Work in progress and can not be updated by Journal Entry,Cont: <b>{0}</b> este capital de lucru în desfășurare și nu poate fi actualizat de jurnalul de intrare,
+Account: {0} is not permitted under Payment Entry,Cont: {0} nu este permis în baza intrării de plată,
+Accounting Dimension <b>{0}</b> is required for 'Balance Sheet' account {1}.,Dimensiunea contabilității <b>{0}</b> este necesară pentru contul „bilanț” {1}.,
+Accounting Dimension <b>{0}</b> is required for 'Profit and Loss' account {1}.,Dimensiunea contabilității <b>{0}</b> este necesară pentru contul „Profit și pierdere” {1}.,
+Accounting Masters,Maeștri contabili,
+Accounting Period overlaps with {0},Perioada de contabilitate se suprapune cu {0},
+Activity,Activitate,
+Add / Manage Email Accounts.,Adăugați / gestionați conturi de e-mail.,
+Add Child,Adăugă Copil,
+Add Loan Security,Adăugați securitatea împrumutului,
+Add Multiple,Adăugați mai multe,
+Add Participants,Adăugă Participanți,
+Add to Featured Item,Adăugați la elementele prezentate,
+Add your review,Adăugați-vă recenzia,
+Add/Edit Coupon Conditions,Adăugați / Editați Condițiile cuponului,
+Added to Featured Items,Adăugat la Elementele prezentate,
+Added {0} ({1}),Adăugat {0} ({1}),
+Address Line 1,Adresă Linie 1,
+Addresses,Adrese,
+Admission End Date should be greater than Admission Start Date.,Data de încheiere a admisiei ar trebui să fie mai mare decât data de începere a admiterii.,
+Against Loan,Contra împrumutului,
+Against Loan:,Împrumut contra,
+All,Toate,
+All bank transactions have been created,Toate tranzacțiile bancare au fost create,
+All the depreciations has been booked,Toate amortizările au fost înregistrate,
+Allocation Expired!,Alocare expirată!,
+Allow Resetting Service Level Agreement from Support Settings.,Permiteți resetarea acordului de nivel de serviciu din setările de asistență,
+Amount of {0} is required for Loan closure,Suma de {0} este necesară pentru închiderea împrumutului,
+Amount paid cannot be zero,Suma plătită nu poate fi zero,
+Applied Coupon Code,Codul cuponului aplicat,
+Apply Coupon Code,Aplicați codul promoțional,
+Appointment Booking,Rezervare rezervare,
+"As there are existing transactions against item {0}, you can not change the value of {1}","Deoarece există tranzacții existente la postul {0}, nu puteți modifica valoarea {1}",
+Asset Id,ID material,
+Asset Value,Valoarea activului,
+Asset Value Adjustment cannot be posted before Asset's purchase date <b>{0}</b>.,Reglarea valorii activelor nu poate fi înregistrată înainte de data achiziției activelor <b>{0}</b> .,
+Asset {0} does not belongs to the custodian {1},Activul {0} nu aparține custodului {1},
+Asset {0} does not belongs to the location {1},Activele {0} nu aparțin locației {1},
+At least one of the Applicable Modules should be selected,Trebuie selectat cel puțin unul dintre modulele aplicabile,
+Atleast one asset has to be selected.,Cel puțin un activ trebuie să fie selectat.,
+Attendance Marked,Prezentare marcată,
+Attendance has been marked as per employee check-ins,Participarea a fost marcată conform check-in-urilor angajaților,
+Authentication Failed,Autentificare esuata,
+Automatic Reconciliation,Reconciliere automată,
+Available For Use Date,Disponibil pentru data de utilizare,
+Available Stock,Stoc disponibil,
+"Available quantity is {0}, you need {1}","Cantitatea disponibilă este {0}, aveți nevoie de {1}",
+BOM 1,BOM 1,
+BOM 2,BOM 2,
+BOM Comparison Tool,Instrument de comparare BOM,
+BOM recursion: {0} cannot be child of {1},Recurs recurs BOM: {0} nu poate fi copil de {1},
+BOM recursion: {0} cannot be parent or child of {1},Recurs din BOM: {0} nu poate fi părinte sau copil de {1},
+Back to Home,Înapoi acasă,
+Back to Messages,Înapoi la mesaje,
+Bank Data mapper doesn't exist,Mapper Data Bank nu există,
+Bank Details,Detalii bancare,
+Bank account '{0}' has been synchronized,Contul bancar „{0}” a fost sincronizat,
+Bank account {0} already exists and could not be created again,Contul bancar {0} există deja și nu a mai putut fi creat din nou,
+Bank accounts added,S-au adăugat conturi bancare,
+Batch no is required for batched item {0},Numărul lot nu este necesar pentru articol lot {0},
+Billing Date,Data de facturare,
+Billing Interval Count cannot be less than 1,Numărul de intervale de facturare nu poate fi mai mic de 1,
+Blue,Albastru,
+Book,Carte,
+Book Appointment,Numire carte,
+Brand,Marca,
+Browse,Parcurgere,
+Call Connected,Apel conectat,
+Call Disconnected,Apel deconectat,
+Call Missed,Sună dor,
+Call Summary,Rezumatul apelului,
+Call Summary Saved,Rezumat apel salvat,
+Cancelled,Anulat,
+Cannot Calculate Arrival Time as Driver Address is Missing.,Nu se poate calcula ora de sosire deoarece adresa șoferului lipsește.,
+Cannot Optimize Route as Driver Address is Missing.,Nu se poate optimiza ruta deoarece adresa șoferului lipsește.,
+Cannot complete task {0} as its dependant task {1} are not ccompleted / cancelled.,Nu se poate finaliza sarcina {0} ca sarcină dependentă {1} nu sunt completate / anulate.,
+Cannot create loan until application is approved,Nu se poate crea împrumut până la aprobarea cererii,
+Cannot find a matching Item. Please select some other value for {0}.,Nu pot găsi o potrivire articol. Vă rugăm să selectați o altă valoare pentru {0}.,
+"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Nu se poate depăși pentru articolul {0} din rândul {1} mai mult decât {2}. Pentru a permite supra-facturarea, vă rugăm să setați alocația în Setările conturilor",
+"Capacity Planning Error, planned start time can not be same as end time","Eroare de planificare a capacității, ora de pornire planificată nu poate fi aceeași cu ora finală",
+Categories,Categorii,
+Changes in {0},Modificări în {0},
+Chart,Diagramă,
+Choose a corresponding payment,Alegeți o plată corespunzătoare,
+Click on the link below to verify your email and confirm the appointment,Faceți clic pe linkul de mai jos pentru a vă confirma e-mailul și pentru a confirma programarea,
+Close,Închideți,
+Communication,Comunicare,
+Compact Item Print,Compact Postul de imprimare,
+Company,Compania,
+Company of asset {0} and purchase document {1} doesn't matches.,Compania de activ {0} și documentul de achiziție {1} nu se potrivesc.,
+Compare BOMs for changes in Raw Materials and Operations,Comparați OM-urile pentru modificările materiilor prime și operațiunilor,
+Compare List function takes on list arguments,Comparați funcția Listă ia argumentele listei,
+Complete,Complet,
+Completed,Finalizat,
+Completed Quantity,Cantitate completată,
+Connect your Exotel Account to ERPNext and track call logs,Conectați contul dvs. Exotel la ERPNext și urmăriți jurnalele de apeluri,
+Connect your bank accounts to ERPNext,Conectați-vă conturile bancare la ERPNext,
+Contact Seller,Contacteaza vanzatorul,
+Continue,Continua,
+Cost Center: {0} does not exist,Centrul de costuri: {0} nu există,
+Couldn't Set Service Level Agreement {0}.,Nu s-a putut stabili acordul de nivel de serviciu {0}.,
+Country,Ţară,
+Country Code in File does not match with country code set up in the system,Codul de țară din fișier nu se potrivește cu codul de țară configurat în sistem,
+Create New Contact,Creați un nou contact,
+Create New Lead,Creați noul plumb,
+Create Pick List,Creați lista de alegeri,
+Create Quality Inspection for Item {0},Creați inspecție de calitate pentru articol {0},
+Creating Accounts...,Crearea de conturi ...,
+Creating bank entries...,Crearea intrărilor bancare ...,
+Credit limit is already defined for the Company {0},Limita de credit este deja definită pentru companie {0},
+Ctrl + Enter to submit,Ctrl + Enter pentru a trimite,
+Ctrl+Enter to submit,Ctrl + Enter pentru a trimite,
+Currency,Valută,
+Current Status,Starea curentă a armatei,
+Customer PO,PO de client,
+Customize,Personalizeaza,
+Daily,Zilnic,
+Date,Dată,
+Date Range,Interval de date,
+Date of Birth cannot be greater than Joining Date.,Data nașterii nu poate fi mai mare decât data de aderare.,
+Dear,Dragă,
+Default,Implicit,
+Define coupon codes.,Definiți codurile cuponului.,
+Delayed Days,Zile amânate,
+Delete,Șterge,
+Delivered Quantity,Cantitate livrată,
+Delivery Notes,Note de livrare,
+Depreciated Amount,Suma depreciată,
+Description,Descriere,
+Designation,Destinatie,
+Difference Value,Valoarea diferenței,
+Dimension Filter,Filtrul de dimensiuni,
+Disabled,Dezactivat,
+Disbursement and Repayment,Plată și rambursare,
+Distance cannot be greater than 4000 kms,Distanța nu poate fi mai mare de 4000 km,
+Do you want to submit the material request,Doriți să trimiteți solicitarea materialului,
+Doctype,doctype,
+Document {0} successfully uncleared,Documentul {0} nu a fost clar necunoscut,
+Download Template,Descărcați Sablon,
+Dr,Dr,
+Due Date,Data Limita,
+Duplicate,Duplicat,
+Duplicate Project with Tasks,Duplică proiect cu sarcini,
+Duplicate project has been created,Proiectul duplicat a fost creat,
+E-Way Bill JSON can only be generated from a submitted document,e-Way Bill JSON poate fi generat numai dintr-un document trimis,
+E-Way Bill JSON can only be generated from submitted document,E-Way Bill JSON poate fi generat numai din documentul trimis,
+E-Way Bill JSON cannot be generated for Sales Return as of now,E-Way Bill JSON nu poate fi generat pentru Returnarea vânzărilor de acum,
+ERPNext could not find any matching payment entry,ERPNext nu a găsit nicio intrare de plată potrivită,
+Earliest Age,Cea mai timpurie vârstă,
+Edit Details,Editează detaliile,
+Edit Profile,Editează profilul,
+Either GST Transporter ID or Vehicle No is required if Mode of Transport is Road,"Fie ID-ul transportatorului GST, fie numărul vehiculului nu este necesar dacă modul de transport este rutier",
+Email,E-mail,
+Email Campaigns,Campanii prin e-mail,
+Employee ID is linked with another instructor,ID-ul angajaților este legat de un alt instructor,
+Employee Tax and Benefits,Impozitul și beneficiile angajaților,
+Employee is required while issuing Asset {0},Angajatul este necesar la emiterea de activ {0},
+Employee {0} does not belongs to the company {1},Angajatul {0} nu aparține companiei {1},
+Enable Auto Re-Order,Activați re-comanda automată,
+End Date of Agreement can't be less than today.,Data de încheiere a acordului nu poate fi mai mică decât astăzi.,
+End Time,End Time,
+Energy Point Leaderboard,Tabloul de bord al punctelor energetice,
+Enter API key in Google Settings.,Introduceți cheia API în Setări Google.,
+Enter Supplier,Introduceți furnizorul,
+Enter Value,Introduceți valoarea,
+Entity Type,Tip de entitate,
+Error,Eroare,
+Error in Exotel incoming call,Eroare în apelul primit la Exotel,
+Error: {0} is mandatory field,Eroare: {0} este câmp obligatoriu,
+Event Link,Link de eveniment,
+Exception occurred while reconciling {0},Excepție a avut loc în timp ce s-a reconciliat {0},
+Expected and Discharge dates cannot be less than Admission Schedule date,Datele preconizate și descărcarea de gestiune nu pot fi mai mici decât Data planificării de admitere,
+Expire Allocation,Expirați alocarea,
+Expired,Expirat,
+Export,Exportă,
+Export not allowed. You need {0} role to export.,Export nu este permisă. Ai nevoie de {0} rolul de a exporta.,
+Failed to add Domain,Nu a putut adăuga Domeniul,
+Fetch Items from Warehouse,Obține obiecte de la Depozit,
+Fetching...,... Fetching,
+Field,Camp,
+File Manager,Manager de fișiere,
+Filters,Filtre,
+Finding linked payments,Găsirea plăților legate,
+Fleet Management,Conducerea flotei,
+Following fields are mandatory to create address:,Următoarele câmpuri sunt obligatorii pentru a crea adresa:,
+For Month,Pentru luna,
+"For item {0} at row {1}, count of serial numbers does not match with the picked quantity","Pentru articolul {0} din rândul {1}, numărul de serii nu se potrivește cu cantitatea aleasă",
+For operation {0}: Quantity ({1}) can not be greter than pending quantity({2}),Pentru operare {0}: cantitatea ({1}) nu poate fi mai mare decât cantitatea în curs ({2}),
+For quantity {0} should not be greater than work order quantity {1},Pentru cantitatea {0} nu trebuie să fie mai mare decât cantitatea de comandă de lucru {1},
+Free item not set in the pricing rule {0},Element gratuit care nu este setat în regula prețurilor {0},
+From Date and To Date are Mandatory,De la data și până la data sunt obligatorii,
+From employee is required while receiving Asset {0} to a target location,De la angajat este necesar în timp ce primiți Active {0} către o locație țintă,
+Fuel Expense,Cheltuieli de combustibil,
+Future Payment Amount,Suma viitoare de plată,
+Future Payment Ref,Plată viitoare Ref,
+Future Payments,Plăți viitoare,
+GST HSN Code does not exist for one or more items,Codul GST HSN nu există pentru unul sau mai multe articole,
+Generate E-Way Bill JSON,Generați JSON Bill e-Way,
+Get Items,Obtine Articole,
+Get Outstanding Documents,Obțineți documente de excepție,
+Goal,Obiectiv,
+Greater Than Amount,Mai mare decât suma,
+Green,Verde,
+Group,Grup,
+Group By Customer,Grup după client,
+Group By Supplier,Grup după furnizor,
+Group Node,Nod Group,
+Group Warehouses cannot be used in transactions. Please change the value of {0},Depozitele de grup nu pot fi utilizate în tranzacții. Vă rugăm să schimbați valoarea {0},
+Help,Ajutor,
+Help Article,articol de ajutor,
+"Helps you keep tracks of Contracts based on Supplier, Customer and Employee","Te ajută să ții evidența contractelor bazate pe furnizor, client și angajat",
+Helps you manage appointments with your leads,Vă ajută să gestionați programările cu clienții dvs.,
+Home,Acasă,
+IBAN is not valid,IBAN nu este valid,
+Import Data from CSV / Excel files.,Importați date din fișiere CSV / Excel.,
+In Progress,In progres,
+Incoming call from {0},Apel primit de la {0},
+Incorrect Warehouse,Depozit incorect,
+Intermediate,Intermediar,
+Invalid Barcode. There is no Item attached to this barcode.,Cod de bare nevalid. Nu există niciun articol atașat acestui cod de bare.,
+Invalid credentials,Credențe nevalide,
+Invite as User,Invitați ca utilizator,
+Issue Priority.,Prioritate de emisiune.,
+Issue Type.,Tipul problemei.,
+"It seems that there is an issue with the server's stripe configuration. In case of failure, the amount will get refunded to your account.","Se pare că există o problemă cu configurația benzii serverului. În caz de eșec, suma va fi rambursată în cont.",
+Item Reported,Articol raportat,
+Item listing removed,Elementul de articol a fost eliminat,
+Item quantity can not be zero,Cantitatea articolului nu poate fi zero,
+Item taxes updated,Impozitele pe articol au fost actualizate,
+Item {0}: {1} qty produced. ,Articol {0}: {1} cantitate produsă.,
+Joining Date can not be greater than Leaving Date,Data de înscriere nu poate fi mai mare decât Data de plecare,
+Lab Test Item {0} already exist,Elementul testului de laborator {0} există deja,
+Last Issue,Ultima problemă,
+Latest Age,Etapă tarzie,
+Leave application is linked with leave allocations {0}. Leave application cannot be set as leave without pay,Cererea de concediu este legată de alocațiile de concediu {0}. Cererea de concediu nu poate fi stabilită ca concediu fără plată,
+Leaves Taken,Frunze luate,
+Less Than Amount,Mai puțin decât suma,
+Liabilities,pasive,
+Loading...,Se încarcă...,
+Loan Amount exceeds maximum loan amount of {0} as per proposed securities,Suma împrumutului depășește valoarea maximă a împrumutului de {0} conform valorilor mobiliare propuse,
+Loan Applications from customers and employees.,Aplicații de împrumut de la clienți și angajați.,
+Loan Disbursement,Decontarea împrumutului,
+Loan Processes,Procese de împrumut,
+Loan Security,Securitatea împrumutului,
+Loan Security Pledge,Gaj de securitate pentru împrumuturi,
+Loan Security Pledge Created : {0},Creditul de securitate al împrumutului creat: {0},
+Loan Security Price,Prețul securității împrumutului,
+Loan Security Price overlapping with {0},Prețul securității împrumutului care se suprapune cu {0},
+Loan Security Unpledge,Unplingge de securitate a împrumutului,
+Loan Security Value,Valoarea securității împrumutului,
+Loan Type for interest and penalty rates,Tip de împrumut pentru dobânzi și rate de penalizare,
+Loan amount cannot be greater than {0},Valoarea împrumutului nu poate fi mai mare de {0},
+Loan is mandatory,Împrumutul este obligatoriu,
+Loans,Credite,
+Loans provided to customers and employees.,Împrumuturi acordate clienților și angajaților.,
+Location,Închiriere,
+Log Type is required for check-ins falling in the shift: {0}.,Tipul de jurnal este necesar pentru check-in-urile care intră în schimb: {0}.,
+Looks like someone sent you to an incomplete URL. Please ask them to look into it.,Se pare că cineva te-a trimis la o adresă URL incompletă. Vă rugăm să cereți-le să se uite în ea.,
+Make Journal Entry,Asigurați Jurnal intrare,
+Make Purchase Invoice,Realizeaza Factura de Cumparare,
+Manufactured,Fabricat,
+Mark Work From Home,Marcați munca de acasă,
+Master,Master,
+Max strength cannot be less than zero.,Rezistența maximă nu poate fi mai mică de zero.,
+Maximum attempts for this quiz reached!,Încercări maxime pentru acest test au fost atinse!,
+Message,Mesaj,
+Missing Values Required,Valorile lipsă necesare,
+Mobile No,Numar de mobil,
+Mobile Number,Numar de mobil,
+Month,Lună,
+Name,Nume,
+Near you,Lângă tine,
+Net Profit/Loss,Profit / Pierdere Netă,
+New Expense,Cheltuieli noi,
+New Invoice,Factură nouă,
+New Payment,Nouă plată,
+New release date should be in the future,Noua dată a lansării ar trebui să fie în viitor,
+Newsletter,Newsletter,
+No Account matched these filters: {},Niciun cont nu se potrivește cu aceste filtre: {},
+No Employee found for the given employee field value. '{}': {},Nu a fost găsit niciun angajat pentru valoarea câmpului dat. &#39;{}&#39;: {},
+No Leaves Allocated to Employee: {0} for Leave Type: {1},Fără frunze alocate angajaților: {0} pentru tipul de concediu: {1},
+No communication found.,Nu a fost găsită nicio comunicare.,
+No correct answer is set for {0},Nu este setat un răspuns corect pentru {0},
+No description,fără descriere,
+No issue has been raised by the caller.,Apelantul nu a pus nicio problemă.,
+No items to publish,Nu există articole de publicat,
+No outstanding invoices found,Nu s-au găsit facturi restante,
+No outstanding invoices found for the {0} {1} which qualify the filters you have specified.,Nu s-au găsit facturi restante pentru {0} {1} care califică filtrele pe care le-ați specificat.,
+No outstanding invoices require exchange rate revaluation,Fără facturi restante nu necesită reevaluarea cursului de schimb,
+No reviews yet,Niciun comentariu încă,
+No views yet,Nu există încă vizionări,
+Non stock items,Articole care nu sunt pe stoc,
+Not Allowed,Nu permise,
+Not allowed to create accounting dimension for {0},Nu este permisă crearea unei dimensiuni contabile pentru {0},
+Not permitted. Please disable the Lab Test Template,Nu sunt acceptate. Vă rugăm să dezactivați șablonul de testare,
+Note,Notă,
+Notes: ,Observații:,
+On Converting Opportunity,La convertirea oportunității,
+On Purchase Order Submission,La trimiterea comenzii de cumpărare,
+On Sales Order Submission,La trimiterea comenzii de vânzare,
+On Task Completion,La finalizarea sarcinii,
+On {0} Creation,La {0} Creație,
+Only .csv and .xlsx files are supported currently,"În prezent, numai fișierele .csv și .xlsx sunt acceptate",
+Only expired allocation can be cancelled,Numai alocarea expirată poate fi anulată,
+Only users with the {0} role can create backdated leave applications,Doar utilizatorii cu rolul {0} pot crea aplicații de concediu retardate,
+Open,Deschide,
+Open Contact,Deschideți contactul,
+Open Lead,Deschideți plumb,
+Opening and Closing,Deschiderea și închiderea,
+Operating Cost as per Work Order / BOM,Costul de operare conform ordinului de lucru / BOM,
+Order Amount,Cantitatea comenzii,
+Page {0} of {1},Pagină {0} din {1},
+Paid amount cannot be less than {0},Suma plătită nu poate fi mai mică de {0},
+Parent Company must be a group company,Compania-mamă trebuie să fie o companie de grup,
+Passing Score value should be between 0 and 100,Valoarea punctajului de trecere ar trebui să fie între 0 și 100,
+Password policy cannot contain spaces or simultaneous hyphens. The format will be restructured automatically,Politica de parolă nu poate conține spații sau cratime simultane. Formatul va fi restructurat automat,
+Patient History,Istoricul pacientului,
+Pause,Pauză,
+Pay,Plăti,
+Payment Document Type,Tip de document de plată,
+Payment Name,Numele de plată,
+Penalty Amount,Suma pedepsei,
+Pending,În așteptarea,
+Performance,Performanţă,
+Period based On,Perioada bazată pe,
+Perpetual inventory required for the company {0} to view this report.,Inventar perpetuu necesar companiei {0} pentru a vedea acest raport.,
+Phone,Telefon,
+Pick List,Lista de alegeri,
+Plaid authentication error,Eroare de autentificare plaidă,
+Plaid public token error,Eroare a simbolului public cu plaid,
+Plaid transactions sync error,Eroare de sincronizare a tranzacțiilor plasate,
+Please check the error log for details about the import errors,Verificați jurnalul de erori pentru detalii despre erorile de import,
+Please create <b>DATEV Settings</b> for Company <b>{}</b>.,Vă rugăm să creați <b>DATEV Setări</b> pentru companie <b>{}</b> .,
+Please create adjustment Journal Entry for amount {0} ,Vă rugăm să creați ajustarea Intrare în jurnal pentru suma {0},
+Please do not create more than 500 items at a time,Vă rugăm să nu creați mai mult de 500 de articole simultan,
+Please enter <b>Difference Account</b> or set default <b>Stock Adjustment Account</b> for company {0},Vă rugăm să introduceți <b>contul de diferență</b> sau să setați <b>contul de ajustare a stocului</b> implicit pentru compania {0},
+Please enter GSTIN and state for the Company Address {0},Vă rugăm să introduceți GSTIN și să indicați adresa companiei {0},
+Please enter Item Code to get item taxes,Vă rugăm să introduceți Codul articolului pentru a obține impozite pe articol,
+Please enter Warehouse and Date,Vă rugăm să introduceți Depozitul și data,
+Please enter the designation,Vă rugăm să introduceți desemnarea,
+Please login as a Marketplace User to edit this item.,Vă rugăm să vă autentificați ca utilizator de piață pentru a edita acest articol.,
+Please login as a Marketplace User to report this item.,Vă rugăm să vă autentificați ca utilizator de piață pentru a raporta acest articol.,
+Please select <b>Template Type</b> to download template,Vă rugăm să selectați <b>Tip de șablon</b> pentru a descărca șablonul,
+Please select Applicant Type first,Vă rugăm să selectați mai întâi tipul de solicitant,
+Please select Customer first,Vă rugăm să selectați Clientul mai întâi,
+Please select Item Code first,Vă rugăm să selectați mai întâi Codul articolului,
+Please select Loan Type for company {0},Vă rugăm să selectați Tip de împrumut pentru companie {0},
+Please select a Delivery Note,Vă rugăm să selectați o notă de livrare,
+Please select a Sales Person for item: {0},Vă rugăm să selectați o persoană de vânzări pentru articol: {0},
+Please select another payment method. Stripe does not support transactions in currency '{0}',Selectați o altă metodă de plată. Stripe nu acceptă tranzacțiile în valută &quot;{0}&quot;,
+Please select the customer.,Vă rugăm să selectați clientul.,
+Please set a Supplier against the Items to be considered in the Purchase Order.,Vă rugăm să setați un furnizor împotriva articolelor care trebuie luate în considerare în comanda de achiziție.,
+Please set account heads in GST Settings for Compnay {0},Vă rugăm să setați capetele de cont în Setările GST pentru Compnay {0},
+Please set an email id for the Lead {0},Vă rugăm să setați un cod de e-mail pentru Lead {0},
+Please set default UOM in Stock Settings,Vă rugăm să setați UOM implicit în Setări stoc,
+Please set filter based on Item or Warehouse due to a large amount of entries.,Vă rugăm să setați filtrul în funcție de articol sau depozit datorită unei cantități mari de înregistrări.,
+Please set up the Campaign Schedule in the Campaign {0},Vă rugăm să configurați Planificarea Campaniei în Campania {0},
+Please set valid GSTIN No. in Company Address for company {0},Vă rugăm să setați numărul GSTIN valid în adresa companiei pentru compania {0},
+Please set {0},Vă rugăm să setați {0},customer
+Please setup a default bank account for company {0},Vă rugăm să configurați un cont bancar implicit pentru companie {0},
+Please specify,Vă rugăm să specificați,
+Please specify a {0},Vă rugăm să specificați un {0},lead
+Pledge Status,Starea gajului,
+Pledge Time,Timp de gaj,
+Printing,Tipărire,
+Priority,Prioritate,
+Priority has been changed to {0}.,Prioritatea a fost modificată la {0}.,
+Priority {0} has been repeated.,Prioritatea {0} a fost repetată.,
+Processing XML Files,Procesarea fișierelor XML,
+Profitability,Rentabilitatea,
+Project,Proiect,
+Proposed Pledges are mandatory for secured Loans,Promisiunile propuse sunt obligatorii pentru împrumuturile garantate,
+Provide the academic year and set the starting and ending date.,Furnizați anul universitar și stabiliți data de început și de încheiere.,
+Public token is missing for this bank,Jurnalul public lipsește pentru această bancă,
+Publish,Publica,
+Publish 1 Item,Publicați 1 articol,
+Publish Items,Publica articole,
+Publish More Items,Publicați mai multe articole,
+Publish Your First Items,Publicați primele dvs. articole,
+Publish {0} Items,Publicați {0} articole,
+Published Items,Articole publicate,
+Purchase Invoice cannot be made against an existing asset {0},Factura de cumpărare nu poate fi făcută cu un activ existent {0},
+Purchase Invoices,Facturi de cumpărare,
+Purchase Orders,Ordine de achiziție,
+Purchase Receipt doesn't have any Item for which Retain Sample is enabled.,Încasarea de cumpărare nu are niciun articol pentru care este activat eșantionul de păstrare.,
+Purchase Return,Înapoi cumpărare,
+Qty of Finished Goods Item,Cantitatea articolului de produse finite,
+Qty or Amount is mandatroy for loan security,Cantitatea sau suma este mandatroy pentru securitatea împrumutului,
+Quality Inspection required for Item {0} to submit,Inspecția de calitate necesară pentru trimiterea articolului {0},
+Quantity to Manufacture,Cantitate de fabricare,
+Quantity to Manufacture can not be zero for the operation {0},Cantitatea de fabricație nu poate fi zero pentru operațiune {0},
+Quarterly,Trimestrial,
+Queued,Coada de așteptare,
+Quick Entry,Intrarea rapidă,
+Quiz {0} does not exist,Chestionarul {0} nu există,
+Quotation Amount,Suma ofertei,
+Rate or Discount is required for the price discount.,Tariful sau Reducerea este necesară pentru reducerea prețului.,
+Reason,Motiv,
+Reconcile Entries,Reconciliați intrările,
+Reconcile this account,Reconciliați acest cont,
+Reconciled,reconciliat,
+Recruitment,Recrutare,
+Red,Roșu,
+Refreshing,Împrospătare,
+Release date must be in the future,Data lansării trebuie să fie în viitor,
+Relieving Date must be greater than or equal to Date of Joining,Data scutirii trebuie să fie mai mare sau egală cu data aderării,
+Rename,Redenumire,
+Rename Not Allowed,Redenumirea nu este permisă,
+Repayment Method is mandatory for term loans,Metoda de rambursare este obligatorie pentru împrumuturile la termen,
+Repayment Start Date is mandatory for term loans,Data de începere a rambursării este obligatorie pentru împrumuturile la termen,
+Report Item,Raport articol,
+Report this Item,Raportați acest articol,
+Reserved Qty for Subcontract: Raw materials quantity to make subcontracted items.,Cantitate rezervată pentru subcontract: cantitate de materii prime pentru a face obiecte subcontractate.,
+Reset,Resetează,
+Reset Service Level Agreement,Resetați Acordul privind nivelul serviciilor,
+Resetting Service Level Agreement.,Resetarea Acordului privind nivelul serviciilor.,
+Return amount cannot be greater unclaimed amount,Suma returnată nu poate fi o sumă nereclamată mai mare,
+Review,Revizuire,
+Room,Cameră,
+Room Type,Tip Cameră,
+Row # ,Rând #,
+Row #{0}: Accepted Warehouse and Supplier Warehouse cannot be same,Rândul # {0}: depozitul acceptat și depozitul furnizorului nu pot fi aceleași,
+Row #{0}: Cannot delete item {1} which has already been billed.,Rândul # {0}: Nu se poate șterge elementul {1} care a fost deja facturat.,
+Row #{0}: Cannot delete item {1} which has already been delivered,Rândul # {0}: Nu se poate șterge articolul {1} care a fost deja livrat,
+Row #{0}: Cannot delete item {1} which has already been received,Rândul # {0}: Nu se poate șterge elementul {1} care a fost deja primit,
+Row #{0}: Cannot delete item {1} which has work order assigned to it.,Rândul # {0}: Nu se poate șterge elementul {1} care i-a fost atribuită o ordine de lucru.,
+Row #{0}: Cannot delete item {1} which is assigned to customer's purchase order.,Rândul # {0}: Nu se poate șterge articolul {1} care este atribuit comenzii de cumpărare a clientului.,
+Row #{0}: Cannot select Supplier Warehouse while suppling raw materials to subcontractor,Rândul # {0}: Nu se poate selecta Furnizorul în timp ce furnizează materii prime subcontractantului,
+Row #{0}: Cost Center {1} does not belong to company {2},Rândul {{0}: Centrul de costuri {1} nu aparține companiei {2},
+Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order {3}. Please update operation status via Job Card {4}.,Rândul # {0}: Operația {1} nu este finalizată pentru {2} cantitate de mărfuri finite în Ordinul de lucru {3}. Vă rugăm să actualizați starea operației prin intermediul cărții de lucru {4}.,
+Row #{0}: Payment document is required to complete the transaction,Rândul # {0}: documentul de plată este necesar pentru a finaliza tranzacția,
+Row #{0}: Serial No {1} does not belong to Batch {2},Rândul # {0}: nr. De serie {1} nu aparține lotului {2},
+Row #{0}: Service End Date cannot be before Invoice Posting Date,Rândul # {0}: Data de încheiere a serviciului nu poate fi înainte de Data de înregistrare a facturii,
+Row #{0}: Service Start Date cannot be greater than Service End Date,Rândul # {0}: Data de începere a serviciului nu poate fi mai mare decât Data de încheiere a serviciului,
+Row #{0}: Service Start and End Date is required for deferred accounting,Rândul # {0}: Data de început și de încheiere a serviciului este necesară pentru contabilitate amânată,
+Row {0}: Invalid Item Tax Template for item {1},Rândul {0}: șablonul de impozit pe articol nevalid pentru articolul {1},
+Row {0}: Quantity not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Rândul {0}: cantitatea nu este disponibilă pentru {4} în depozit {1} la momentul înregistrării la intrare ({2} {3}),
+Row {0}: user has not applied the rule {1} on the item {2},Rândul {0}: utilizatorul nu a aplicat regula {1} pe articolul {2},
+Row {0}:Sibling Date of Birth cannot be greater than today.,Rândul {0}: Data nașterii în materie nu poate fi mai mare decât astăzi.,
+Row({0}): {1} is already discounted in {2},Rândul ({0}): {1} este deja actualizat în {2},
+Rows Added in {0},Rânduri adăugate în {0},
+Rows Removed in {0},Rândurile eliminate în {0},
+Sanctioned Amount limit crossed for {0} {1},Limita sumei sancționate depășită pentru {0} {1},
+Sanctioned Loan Amount already exists for {0} against company {1},Suma de împrumut sancționat există deja pentru {0} față de compania {1},
+Save,Salvează,
+Save Item,Salvare articol,
+Saved Items,Articole salvate,
+Search Items ...,Caută articole ...,
+Search for a payment,Căutați o plată,
+Search for anything ...,Căutați orice ...,
+Search results for,cauta rezultate pentru,
+Select All,Selectează toate,
+Select Difference Account,Selectați Cont de diferență,
+Select a Default Priority.,Selectați o prioritate implicită.,
+Select a company,Selectați o companie,
+Select finance book for the item {0} at row {1},Selectați cartea de finanțe pentru articolul {0} din rândul {1},
+Select only one Priority as Default.,Selectați doar o prioritate ca implicită.,
+Seller Information,Informatiile vanzatorului,
+Send,Trimiteți,
+Send a message,Trimite un mesaj,
+Sending,Trimitere,
+Sends Mails to lead or contact based on a Campaign schedule,Trimite e-mailuri pentru a conduce sau a contacta pe baza unui program de campanie,
+Serial Number Created,Număr de serie creat,
+Serial Numbers Created,Numere de serie create,
+Serial no(s) required for serialized item {0},Numărul (numerele) de serie necesare pentru articolul serializat {0},
+Series,Serii,
+Server Error,Eroare de server,
+Service Level Agreement has been changed to {0}.,Acordul privind nivelul serviciilor a fost modificat în {0}.,
+Service Level Agreement was reset.,Acordul privind nivelul serviciilor a fost resetat.,
+Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Acordul privind nivelul serviciului cu tipul de entitate {0} și entitatea {1} există deja.,
+Set,Setează,
+Set Meta Tags,Setați etichete meta,
+Set {0} in company {1},Setați {0} în companie {1},
+Setup,Configurare,
+Setup Wizard,Vrăjitor Configurare,
+Shift Management,Managementul schimbării,
+Show Future Payments,Afișați plăți viitoare,
+Show Linked Delivery Notes,Afișare Note de livrare conexe,
+Show Sales Person,Afișați persoana de vânzări,
+Show Stock Ageing Data,Afișează date de îmbătrânire a stocurilor,
+Show Warehouse-wise Stock,Afișați stocul înțelept,
+Size,Dimensiune,
+Something went wrong while evaluating the quiz.,Ceva nu a mers în timp ce evaluați testul.,
+Sr,sr,
+Start,Început(Pornire),
+Start Date cannot be before the current date,Data de început nu poate fi înainte de data curentă,
+Start Time,Ora de începere,
+Status,Status,
+Status must be Cancelled or Completed,Starea trebuie anulată sau completată,
+Stock Balance Report,Raportul soldului stocurilor,
+Stock Entry has been already created against this Pick List,Intrarea pe stoc a fost deja creată pe baza acestei liste de alegeri,
+Stock Ledger ID,ID evidență stoc,
+Stock Value ({0}) and Account Balance ({1}) are out of sync for account {2} and it's linked warehouses.,Valoarea stocului ({0}) și soldul contului ({1}) nu sunt sincronizate pentru contul {2} și sunt depozite legate.,
+Stores - {0},Magazine - {0},
+Student with email {0} does not exist,Studentul cu e-mail {0} nu există,
+Submit Review,Trimite recenzie,
+Submitted,Inscrisa,
+Supplier Addresses And Contacts,Adrese furnizorului și de Contacte,
+Synchronize this account,Sincronizați acest cont,
+Tag,Etichetă,
+Target Location is required while receiving Asset {0} from an employee,Locația țintă este necesară în timp ce primiți activ {0} de la un angajat,
+Target Location is required while transferring Asset {0},Locația țintă este necesară în timpul transferului de active {0},
+Target Location or To Employee is required while receiving Asset {0},Locația țintei sau către angajat este necesară în timp ce primiți activ {0},
+Task's {0} End Date cannot be after Project's End Date.,Data de încheiere a sarcinii {0} nu poate fi după data de încheiere a proiectului.,
+Task's {0} Start Date cannot be after Project's End Date.,Data de început a sarcinii {0} nu poate fi după data de încheiere a proiectului.,
+Tax Account not specified for Shopify Tax {0},Contul fiscal nu este specificat pentru Shopify Tax {0},
+Tax Total,Total impozit,
+Template,Șablon,
+The Campaign '{0}' already exists for the {1} '{2}',Campania „{0}” există deja pentru {1} &#39;{2}&#39;,
+The difference between from time and To Time must be a multiple of Appointment,Diferența dintre timp și To Time trebuie să fie multiplu de numire,
+The field Asset Account cannot be blank,Câmpul Contul de active nu poate fi gol,
+The field Equity/Liability Account cannot be blank,Câmpul Contul de capitaluri proprii / pasiv nu poate fi necompletat,
+The following serial numbers were created: <br><br> {0},Au fost create următoarele numere de serie: <br><br> {0},
+The parent account {0} does not exists in the uploaded template,Contul părinte {0} nu există în șablonul încărcat,
+The question cannot be duplicate,Întrebarea nu poate fi duplicată,
+The selected payment entry should be linked with a creditor bank transaction,Intrarea de plată selectată trebuie să fie legată de o tranzacție bancară cu creditor,
+The selected payment entry should be linked with a debtor bank transaction,Intrarea de plată selectată trebuie să fie legată de o tranzacție bancară cu debitori,
+The total allocated amount ({0}) is greated than the paid amount ({1}).,Suma totală alocată ({0}) este majorată decât suma plătită ({1}).,
+There are no vacancies under staffing plan {0},Nu există locuri vacante conform planului de personal {0},
+This Service Level Agreement is specific to Customer {0},Acest Acord de nivel de serviciu este specific Clientului {0},
+This action will unlink this account from any external service integrating ERPNext with your bank accounts. It cannot be undone. Are you certain ?,Această acțiune va deconecta acest cont de orice serviciu extern care integrează ERPNext cu conturile dvs. bancare. Nu poate fi anulată. Esti sigur ?,
+This bank account is already synchronized,Acest cont bancar este deja sincronizat,
+This bank transaction is already fully reconciled,Această tranzacție bancară este deja complet reconciliată,
+This employee already has a log with the same timestamp.{0},Acest angajat are deja un jurnal cu aceeași oră de timp. {0},
+This page keeps track of items you want to buy from sellers.,Această pagină ține evidența articolelor pe care doriți să le cumpărați de la vânzători.,
+This page keeps track of your items in which buyers have showed some interest.,Această pagină ține evidența articolelor dvs. pentru care cumpărătorii au arătat interes.,
+Thursday,Joi,
+Timing,Sincronizare,
+Title,Titlu,
+"To allow over billing, update ""Over Billing Allowance"" in Accounts Settings or the Item.","Pentru a permite facturarea excesivă, actualizați „Indemnizație de facturare” în Setări conturi sau element.",
+"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Pentru a permite primirea / livrarea, actualizați „Indemnizația de primire / livrare” în Setări de stoc sau articol.",
+To date needs to be before from date,Până în prezent trebuie să fie înainte de această dată,
+Total,Total,
+Total Early Exits,Total Ieșiri anticipate,
+Total Late Entries,Total intrări târzii,
+Total Payment Request amount cannot be greater than {0} amount,Suma totală a solicitării de plată nu poate fi mai mare decât {0},
+Total payments amount can't be greater than {},Valoarea totală a plăților nu poate fi mai mare de {},
+Totals,Totaluri,
+Training Event:,Eveniment de formare:,
+Transactions already retreived from the statement,Tranzacțiile au fost retrase din extras,
+Transfer Material to Supplier,Transfer de material la furnizor,
+Transport Receipt No and Date are mandatory for your chosen Mode of Transport,Numărul de recepție și data de transport nu sunt obligatorii pentru modul de transport ales,
+Tuesday,Marți,
+Type,Tip,
+Unable to find Salary Component {0},Imposibil de găsit componentul salariului {0},
+Unable to find the time slot in the next {0} days for the operation {1}.,Nu se poate găsi intervalul orar în următoarele {0} zile pentru operația {1}.,
+Unable to update remote activity,Imposibil de actualizat activitatea de la distanță,
+Unknown Caller,Apelant necunoscut,
+Unlink external integrations,Deconectați integrările externe,
+Unmarked Attendance for days,Participarea nemarcată zile întregi,
+Unpublish Item,Publicarea articolului,
+Unreconciled,nereconciliat,
+Unsupported GST Category for E-Way Bill JSON generation,Categorie GST neacceptată pentru generarea JSON Bill E-Way,
+Update,Actualizare,
+Update Details,Detalii detalii,
+Update Taxes for Items,Actualizați impozitele pentru articole,
+"Upload a bank statement, link or reconcile a bank account","Încărcați un extras bancar, conectați sau reconciliați un cont bancar",
+Upload a statement,Încărcați o declarație,
+Use a name that is different from previous project name,Utilizați un nume diferit de numele proiectului anterior,
+User {0} is disabled,Utilizatorul {0} este dezactivat,
+Users and Permissions,Utilizatori și permisiuni,
+Vacancies cannot be lower than the current openings,Posturile vacante nu pot fi mai mici decât deschiderile actuale,
+Valid From Time must be lesser than Valid Upto Time.,Valid From Time trebuie să fie mai mic decât Valid Upto Time.,
+Valuation Rate required for Item {0} at row {1},Rata de evaluare necesară pentru articolul {0} la rândul {1},
+Values Out Of Sync,Valori ieșite din sincronizare,
+Vehicle Type is required if Mode of Transport is Road,Tip de vehicul este necesar dacă modul de transport este rutier,
+Vendor Name,Numele vânzătorului,
+Verify Email,Verificați e-mail,
+View,Vedere,
+View all issues from {0},Vedeți toate problemele din {0},
+View call log,Vizualizați jurnalul de apeluri,
+Warehouse,Depozit,
+Warehouse not found against the account {0},Depozitul nu a fost găsit în contul {0},
+Welcome to {0},Bine ai venit la {0},
+Why do think this Item should be removed?,De ce credeți că acest articol ar trebui eliminat?,
+Work Order {0}: Job Card not found for the operation {1},Comandă de lucru {0}: cartea de muncă nu a fost găsită pentru operație {1},
+Workday {0} has been repeated.,Ziua lucrătoare {0} a fost repetată.,
+XML Files Processed,Fișiere XML procesate,
+Year,An,
+Yearly,Anual,
+You,Tu,
+You are not allowed to enroll for this course,Nu aveți voie să vă înscrieți la acest curs,
+You are not enrolled in program {0},Nu sunteți înscris în programul {0},
+You can Feature upto 8 items.,Puteți prezenta până la 8 articole.,
+You can also copy-paste this link in your browser,"De asemenea, puteți să copiați-paste această legătură în browser-ul dvs.",
+You can publish upto 200 items.,Puteți publica până la 200 de articole.,
+You have to enable auto re-order in Stock Settings to maintain re-order levels.,Trebuie să activați re-comanda auto în Setări stoc pentru a menține nivelurile de re-comandă.,
+You must be a registered supplier to generate e-Way Bill,Pentru a genera Bill e-Way trebuie să fiți un furnizor înregistrat,
+You need to login as a Marketplace User before you can add any reviews.,Trebuie să vă autentificați ca utilizator de piață înainte de a putea adăuga recenzii.,
+Your Featured Items,Articolele dvs. recomandate,
+Your Items,Articolele dvs.,
+Your Profile,Profilul tau,
+Your rating:,Rating-ul tău:,
+and,și,
+e-Way Bill already exists for this document,e-Way Bill există deja pentru acest document,
+woocommerce - {0},woocommerce - {0},
+{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Cuponul utilizat este {1}. Cantitatea admisă este epuizată,
+{0} Name,{0} Nume,
+{0} Operations: {1},{0} Operații: {1},
+{0} bank transaction(s) created,{0} tranzacțiile bancare create,
+{0} bank transaction(s) created and {1} errors,{0} tranzacțiile bancare create și {1} erori,
+{0} can not be greater than {1},{0} nu poate fi mai mare de {1},
+{0} conversations,{0} conversații,
+{0} is not a company bank account,{0} nu este un cont bancar al companiei,
+{0} is not a group node. Please select a group node as parent cost center,{0} nu este un nod de grup. Vă rugăm să selectați un nod de grup ca centru de costuri parentale,
+{0} is not the default supplier for any items.,{0} nu este furnizorul prestabilit pentru niciun articol.,
+{0} is required,{0} este necesar,
+{0}: {1} must be less than {2},{0}: {1} trebuie să fie mai mic decât {2},
+{} is an invalid Attendance Status.,{} este o stare de prezență nevalidă.,
+{} is required to generate E-Way Bill JSON,{} este necesar pentru a genera Bill JSON E-Way,
+"Invalid lost reason {0}, please create a new lost reason","Motiv pierdut nevalabil {0}, vă rugăm să creați un motiv nou pierdut",
+Profit This Year,Profit anul acesta,
+Total Expense,Cheltuieli totale,
+Total Expense This Year,Cheltuieli totale în acest an,
+Total Income,Venit total,
+Total Income This Year,Venit total în acest an,
+Barcode,coduri de bare,
+Bold,Îndrăzneţ,
+Center,Centru,
+Clear,clar,
+Comment,cometariu,
+Comments,Comentarii,
+DocType,DocType,
+Download,Descarca,
+Left,Stânga,
+Link,Legătură,
+New,Nou,
+Not Found,Nu a fost găsit,
+Print,Imprimare,
+Reference Name,nume de referinta,
+Refresh,Actualizare,
+Success,Succes,
+Time,Timp,
+Value,Valoare,
+Actual,Real,
+Add to Cart,Adăugaţi în Coş,
+Days Since Last Order,Zile de la ultima comandă,
+In Stock,In stoc,
+Loan Amount is mandatory,Suma împrumutului este obligatorie,
+Mode Of Payment,Modul de plată,
+No students Found,Nu au fost găsiți studenți,
+Not in Stock,Nu este în stoc,
+Please select a Customer,Selectați un client,
+Printed On,imprimat pe,
+Received From,Primit de la,
+Sales Person,Persoană de vânzări,
+To date cannot be before From date,Până în prezent nu poate fi înainte de data,
+Write Off,Achita,
+{0} Created,{0} a fost creat,
+Email Id,ID-ul de e-mail,
+No,Nu,
+Reference Doctype,DocType referință,
+User Id,Numele de utilizator,
+Yes,da,
+Actual ,Efectiv,
+Add to cart,Adăugaţi în Coş,
+Budget,Buget,
+Chart of Accounts,Grafic de conturi,
+Customer database.,Baza de date pentru clienți.,
+Days Since Last order,Zile de la ultima comandă,
+Download as JSON,Descărcați ca JSON,
+End date can not be less than start date,Data de Incheiere nu poate fi anterioara Datei de Incepere,
+For Default Supplier (Optional),Pentru furnizor implicit (opțional),
+From date cannot be greater than To date,De la data nu poate fi mai mare decât la data,
+Group by,Grupul De,
+In stock,In stoc,
+Item name,Denumire Articol,
+Loan amount is mandatory,Suma împrumutului este obligatorie,
+Minimum Qty,Cantitatea minimă,
+More details,Mai multe detalii,
+Nature of Supplies,Natura aprovizionării,
+No Items found.,Nu au fost gasite articolele.,
+No employee found,Nu a fost găsit angajat,
+No students found,Nu există elevi găsit,
+Not in stock,Nu este în stoc,
+Not permitted,Nu sunt acceptate,
+Open Issues ,Probleme deschise,
+Open Projects ,Deschide Proiecte,
+Open To Do ,Deschideți To Do,
+Operation Id,Operațiunea ID,
+Partially ordered,Comandat parțial,
+Please select company first,Selectați prima companie,
+Please select patient,Selectați pacientul,
+Printed On ,Tipărit pe,
+Projected qty,Numărul estimat,
+Sales person,Persoană de vânzări,
+Serial No {0} Created,Serial Nu {0} a creat,
+Source Location is required for the Asset {0},Sursa Locația este necesară pentru elementul {0},
+Tax Id,Cod de identificare fiscală,
+To Time,La timp,
+To date cannot be before from date,Până în prezent nu poate fi înainte de De la dată,
+Total Taxable value,Valoarea impozabilă totală,
+Upcoming Calendar Events ,Evenimente viitoare Calendar,
+Value or Qty,Valoare sau cantitate,
+Variance ,variație,
+Variant of,Varianta de,
+Write off,Achita,
+hours,ore,
+received from,primit de la,
+to,Până la data,
+Cards,Carduri,
+Percentage,Procent,
+Failed to setup defaults for country {0}. Please contact support@erpnext.com,Eroare la configurarea valorilor prestabilite pentru țară {0}. Vă rugăm să contactați support@erpnext.com,
+Row #{0}: Item {1} is not a Serialized/Batched Item. It cannot have a Serial No/Batch No against it.,Rândul # {0}: Elementul {1} nu este un articol serializat / batat. Nu poate avea un număr de serie / nr.,
+Please set {0},Vă rugăm să setați {0},
+Please set {0},Vă rugăm să setați {0},supplier
+Draft,Proiect,"docstatus,=,0"
+Cancelled,Anulat,"docstatus,=,2"
+Please setup Instructor Naming System in Education > Education Settings,Vă rugăm să configurați sistemul de numire a instructorului în educație&gt; Setări educație,
+Please set Naming Series for {0} via Setup > Settings > Naming Series,Vă rugăm să setați Naming Series pentru {0} prin Setare&gt; Setări&gt; Serie pentru denumire,
+UOM Conversion factor ({0} -> {1}) not found for item: {2},Factorul de conversie UOM ({0} -&gt; {1}) nu a fost găsit pentru articol: {2},
+Item Code > Item Group > Brand,Cod articol&gt; Grup de articole&gt; Marcă,
+Customer > Customer Group > Territory,Client&gt; Grup de clienți&gt; Teritoriul,
+Supplier > Supplier Type,Furnizor&gt; Tip furnizor,
+Please setup Employee Naming System in Human Resource > HR Settings,Vă rugăm să configurați sistemul de numire a angajaților în resurse umane&gt; Setări HR,
+Please setup numbering series for Attendance via Setup > Numbering Series,Vă rugăm să configurați seria de numerotare pentru prezență prin Setare&gt; Numerotare,
+The value of {0} differs between Items {1} and {2},Valoarea {0} diferă între elementele {1} și {2},
+Auto Fetch,Preluare automată,
+Fetch Serial Numbers based on FIFO,Obțineți numerele de serie pe baza FIFO,
+"Outward taxable supplies(other than zero rated, nil rated and exempted)","Consumabile impozabile (altele decât zero, zero și scutite)",
+"To allow different rates, disable the {0} checkbox in {1}.","Pentru a permite tarife diferite, dezactivați caseta de selectare {0} din {1}.",
+Current Odometer Value should be greater than Last Odometer Value {0},Valoarea curentă a kilometrului ar trebui să fie mai mare decât ultima valoare a kilometrului {0},
+No additional expenses has been added,Nu s-au adăugat cheltuieli suplimentare,
+Asset{} {assets_link} created for {},Element {} {assets_link} creat pentru {},
+Row {}: Asset Naming Series is mandatory for the auto creation for item {},Rând {}: Seria de denumire a activelor este obligatorie pentru crearea automată a articolului {},
+Assets not created for {0}. You will have to create asset manually.,Elemente care nu au fost create pentru {0}. Va trebui să creați manual activul.,
+{0} {1} has accounting entries in currency {2} for company {3}. Please select a receivable or payable account with currency {2}.,{0} {1} are înregistrări contabile în valută {2} pentru companie {3}. Vă rugăm să selectați un cont de primit sau de plătit cu moneda {2}.,
+Invalid Account,Cont invalid,
+Purchase Order Required,Comandă de aprovizionare necesare,
+Purchase Receipt Required,Cumpărare de primire Obligatoriu,
+Account Missing,Cont lipsă,
+Requested,Solicitată,
+Partially Paid,Parțial plătit,
+Invalid Account Currency,Moneda contului este nevalidă,
+"Row {0}: The item {1}, quantity must be positive number","Rândul {0}: elementul {1}, cantitatea trebuie să fie un număr pozitiv",
+"Please set {0} for Batched Item {1}, which is used to set {2} on Submit.","Vă rugăm să setați {0} pentru articolul lot {1}, care este utilizat pentru a seta {2} la Trimitere.",
+Expiry Date Mandatory,Data de expirare Obligatorie,
+Variant Item,Variant Item,
+BOM 1 {0} and BOM 2 {1} should not be same,BOM 1 {0} și BOM 2 {1} nu ar trebui să fie aceleași,
+Note: Item {0} added multiple times,Notă: articolul {0} a fost adăugat de mai multe ori,
+YouTube,YouTube,
+Vimeo,Vimeo,
+Publish Date,Data publicării,
+Duration,Durată,
+Advanced Settings,Setari avansate,
+Path,cale,
+Components,Componente,
+Verified By,Verificate de,
+Invalid naming series (. missing) for {0},Serii de denumiri nevalide (. Lipsesc) pentru {0},
+Filter Based On,Filtrare bazată pe,
+Reqd by date,Reqd după dată,
+Manufacturer Part Number <b>{0}</b> is invalid,Numărul de piesă al producătorului <b>{0}</b> este nevalid,
+Invalid Part Number,Număr de piesă nevalid,
+Select atleast one Social Media from Share on.,Selectați cel puțin o rețea socială din Partajare pe.,
+Invalid Scheduled Time,Ora programată nevalidă,
+Length Must be less than 280.,Lungimea trebuie să fie mai mică de 280.,
+Error while POSTING {0},Eroare la POSTARE {0},
+"Session not valid, Do you want to login?","Sesiunea nu este validă, doriți să vă autentificați?",
+Session Active,Sesiune activă,
+Session Not Active. Save doc to login.,Sesiunea nu este activă. Salvați documentul pentru autentificare.,
+Error! Failed to get request token.,Eroare! Nu s-a obținut indicativul de solicitare,
+Invalid {0} or {1},{0} sau {1} nevalid,
+Error! Failed to get access token.,Eroare! Nu s-a obținut jetonul de acces.,
+Invalid Consumer Key or Consumer Secret Key,Cheie consumator nevalidă sau cheie secretă consumator,
+Your Session will be expire in ,Sesiunea dvs. va expira în,
+ days.,zile.,
+Session is expired. Save doc to login.,Sesiunea a expirat. Salvați documentul pentru autentificare.,
+Error While Uploading Image,Eroare la încărcarea imaginii,
+You Didn't have permission to access this API,Nu ați avut permisiunea de a accesa acest API,
+Valid Upto date cannot be before Valid From date,Valid Upto date nu poate fi înainte de Valid From date,
+Valid From date not in Fiscal Year {0},Valabil de la data care nu se află în anul fiscal {0},
+Valid Upto date not in Fiscal Year {0},Data actualizată valabilă nu în anul fiscal {0},
+Group Roll No,Rola grupului nr,
+Maintain Same Rate Throughout Sales Cycle,Menține Aceeași Rată in Cursul Ciclului de Vânzări,
+"Row {1}: Quantity ({0}) cannot be a fraction. To allow this, disable '{2}' in UOM {3}.","Rândul {1}: Cantitatea ({0}) nu poate fi o fracțiune. Pentru a permite acest lucru, dezactivați „{2}” în UOM {3}.",
+Must be Whole Number,Trebuie să fie Număr întreg,
+Please setup Razorpay Plan ID,Configurați ID-ul planului Razorpay,
+Contact Creation Failed,Crearea contactului nu a reușit,
+{0} already exists for employee {1} and period {2},{0} există deja pentru angajat {1} și perioada {2},
+Leaves Allocated,Frunze alocate,
+Leaves Expired,Frunzele au expirat,
+Leave Without Pay does not match with approved {} records,Concediu fără plată nu se potrivește cu înregistrările {} aprobate,
+Income Tax Slab not set in Salary Structure Assignment: {0},Placa de impozit pe venit nu este setată în atribuirea structurii salariale: {0},
+Income Tax Slab: {0} is disabled,Planșa impozitului pe venit: {0} este dezactivat,
+Income Tax Slab must be effective on or before Payroll Period Start Date: {0},Placa pentru impozitul pe venit trebuie să fie efectivă la data de începere a perioadei de salarizare sau înainte de aceasta: {0},
+No leave record found for employee {0} on {1},Nu s-a găsit nicio evidență de concediu pentru angajatul {0} pe {1},
+Row {0}: {1} is required in the expenses table to book an expense claim.,Rândul {0}: {1} este necesar în tabelul de cheltuieli pentru a rezerva o cerere de cheltuieli.,
+Set the default account for the {0} {1},Setați contul prestabilit pentru {0} {1},
+(Half Day),(Jumătate de zi),
+Income Tax Slab,Placa impozitului pe venit,
+Row #{0}: Cannot set amount or formula for Salary Component {1} with Variable Based On Taxable Salary,Rândul # {0}: Nu se poate stabili suma sau formula pentru componenta salariu {1} cu variabilă pe baza salariului impozabil,
+Row #{}: {} of {} should be {}. Please modify the account or select a different account.,Rândul # {}: {} din {} ar trebui să fie {}. Vă rugăm să modificați contul sau să selectați un alt cont.,
+Row #{}: Please asign task to a member.,Rândul # {}: atribuiți sarcina unui membru.,
+Process Failed,Procesul nu a reușit,
+Tally Migration Error,Eroare de migrare Tally,
+Please set Warehouse in Woocommerce Settings,Vă rugăm să setați Depozitul în Setările Woocommerce,
+Row {0}: Delivery Warehouse ({1}) and Customer Warehouse ({2}) can not be same,Rândul {0}: Depozitul de livrare ({1}) și Depozitul pentru clienți ({2}) nu pot fi identice,
+Row {0}: Due Date in the Payment Terms table cannot be before Posting Date,Rândul {0}: Data scadenței din tabelul Condiții de plată nu poate fi înainte de Data înregistrării,
+Cannot find {} for item {}. Please set the same in Item Master or Stock Settings.,Nu se poate găsi {} pentru articol {}. Vă rugăm să setați același lucru în Setări articol principal sau stoc,
+Row #{0}: The batch {1} has already expired.,Rândul # {0}: lotul {1} a expirat deja.,
+Start Year and End Year are mandatory,Anul de început și anul de sfârșit sunt obligatorii,
+GL Entry,Intrari GL,
+Cannot allocate more than {0} against payment term {1},Nu se pot aloca mai mult de {0} contra termenului de plată {1},
+The root account {0} must be a group,Contul rădăcină {0} trebuie să fie un grup,
+Shipping rule not applicable for country {0} in Shipping Address,Regula de expediere nu se aplică pentru țara {0} din adresa de expediere,
+Get Payments from,Primiți plăți de la,
+Set Shipping Address or Billing Address,Setați adresa de expediere sau adresa de facturare,
+Consultation Setup,Configurarea consultării,
+Fee Validity,Valabilitate taxă,
+Laboratory Setup,Configurarea laboratorului,
+Dosage Form,Formă de dozare,
+Records and History,Înregistrări și istorie,
+Patient Medical Record,Dosarul medical al pacientului,
+Rehabilitation,Reabilitare,
+Exercise Type,Tipul de exercițiu,
+Exercise Difficulty Level,Nivelul de dificultate al exercițiului,
+Therapy Type,Tip de terapie,
+Therapy Plan,Planul de terapie,
+Therapy Session,Sesiune de terapie,
+Motor Assessment Scale,Scara de evaluare motorie,
+[Important] [ERPNext] Auto Reorder Errors,[Important] [ERPNext] Erori de reordonare automată,
+"Regards,","Salutari,",
+The following {0} were created: {1},Au fost create următoarele {0}: {1},
+Work Orders,comenzi de lucru,
+The {0} {1} created sucessfully,{0} {1} a fost creat cu succes,
+Work Order cannot be created for following reason: <br> {0},Ordinea de lucru nu poate fi creată din următorul motiv:<br> {0},
+Add items in the Item Locations table,Adăugați elemente în tabelul Locații element,
+Update Current Stock,Actualizați stocul curent,
+"{0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Păstrarea eșantionului se bazează pe lot, vă rugăm să bifați Are Batch No pentru a păstra eșantionul articolului",
+Empty,Gol,
+Currently no stock available in any warehouse,În prezent nu există stoc disponibil în niciun depozit,
+BOM Qty,Cantitatea BOM,
+Time logs are required for {0} {1},Jurnalele de timp sunt necesare pentru {0} {1},
+Total Completed Qty,Cantitatea totală completată,
+Qty to Manufacture,Cantitate pentru fabricare,
+Repay From Salary can be selected only for term loans,Rambursarea din salariu poate fi selectată numai pentru împrumuturile pe termen,
+No valid Loan Security Price found for {0},Nu s-a găsit un preț valid de securitate a împrumutului pentru {0},
+Loan Account and Payment Account cannot be same,Contul de împrumut și Contul de plată nu pot fi aceleași,
+Loan Security Pledge can only be created for secured loans,Garanția de securitate a împrumutului poate fi creată numai pentru împrumuturile garantate,
+Social Media Campaigns,Campanii de socializare,
+From Date can not be greater than To Date,From Date nu poate fi mai mare decât To Date,
+Please set a Customer linked to the Patient,Vă rugăm să setați un client legat de pacient,
+Customer Not Found,Clientul nu a fost găsit,
+Please Configure Clinical Procedure Consumable Item in ,Vă rugăm să configurați articolul consumabil pentru procedura clinică în,
+Missing Configuration,Configurare lipsă,
+Out Patient Consulting Charge Item,Aflați articolul de taxare pentru consultanță pentru pacient,
+Inpatient Visit Charge Item,Taxă pentru vizitarea pacientului,
+OP Consulting Charge,OP Taxă de consultanță,
+Inpatient Visit Charge,Taxă pentru vizitarea bolnavului,
+Appointment Status,Starea numirii,
+Test: ,Test:,
+Collection Details: ,Detalii colecție:,
+{0} out of {1},{0} din {1},
+Select Therapy Type,Selectați Tip de terapie,
+{0} sessions completed,{0} sesiuni finalizate,
+{0} session completed,{0} sesiune finalizată,
+ out of {0},din {0},
+Therapy Sessions,Ședințe de terapie,
+Add Exercise Step,Adăugați Pasul de exerciții,
+Edit Exercise Step,Editați Pasul de exerciții,
+Patient Appointments,Programări pentru pacienți,
+Item with Item Code {0} already exists,Elementul cu codul articolului {0} există deja,
+Registration Fee cannot be negative or zero,Taxa de înregistrare nu poate fi negativă sau zero,
+Configure a service Item for {0},Configurați un articol de serviciu pentru {0},
+Temperature: ,Temperatura:,
+Pulse: ,Puls:,
+Respiratory Rate: ,Rata respiratorie:,
+BP: ,BP:,
+BMI: ,IMC:,
+Note: ,Notă:,
+Check Availability,Verifică Disponibilitate,
+Please select Patient first,Vă rugăm să selectați mai întâi Pacient,
+Please select a Mode of Payment first,Vă rugăm să selectați mai întâi un mod de plată,
+Please set the Paid Amount first,Vă rugăm să setați mai întâi suma plătită,
+Not Therapies Prescribed,Nu terapii prescrise,
+There are no Therapies prescribed for Patient {0},Nu există terapii prescrise pentru pacient {0},
+Appointment date and Healthcare Practitioner are Mandatory,Data numirii și medicul sunt obligatorii,
+No Prescribed Procedures found for the selected Patient,Nu s-au găsit proceduri prescrise pentru pacientul selectat,
+Please select a Patient first,Vă rugăm să selectați mai întâi un pacient,
+There are no procedure prescribed for ,Nu există o procedură prescrisă pentru,
+Prescribed Therapies,Terapii prescrise,
+Appointment overlaps with ,Programarea se suprapune cu,
+{0} has appointment scheduled with {1} at {2} having {3} minute(s) duration.,{0} are programată o întâlnire cu {1} la {2} cu o durată de {3} minute.,
+Appointments Overlapping,Programări care se suprapun,
+Consulting Charges: {0},Taxe de consultanță: {0},
+Appointment Cancelled. Please review and cancel the invoice {0},Programare anulată. Examinați și anulați factura {0},
+Appointment Cancelled.,Programare anulată.,
+Fee Validity {0} updated.,Valabilitatea taxei {0} actualizată.,
+Practitioner Schedule Not Found,Programul practicantului nu a fost găsit,
+{0} is on a Half day Leave on {1},{0} este într-un concediu de jumătate de zi pe {1},
+{0} is on Leave on {1},{0} este în concediu pe {1},
+{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner,{0} nu are un program de asistență medicală. Adăugați-l în Healthcare Practitioner,
+Healthcare Service Units,Unități de servicii medicale,
+Complete and Consume,Completează și consumă,
+Complete {0} and Consume Stock?,Completați {0} și consumați stoc?,
+Complete {0}?,Completați {0}?,
+Stock quantity to start the Procedure is not available in the Warehouse {0}. Do you want to record a Stock Entry?,Cantitatea de stoc pentru a începe procedura nu este disponibilă în depozit {0}. Doriți să înregistrați o înregistrare de stoc?,
+{0} as on {1},{0} ca pe {1},
+Clinical Procedure ({0}):,Procedură clinică ({0}):,
+Please set Customer in Patient {0},Vă rugăm să setați Clientul în Pacient {0},
+Item {0} is not active,Elementul {0} nu este activ,
+Therapy Plan {0} created successfully.,Planul de terapie {0} a fost creat cu succes.,
+Symptoms: ,Simptome:,
+No Symptoms,Fără simptome,
+Diagnosis: ,Diagnostic:,
+No Diagnosis,Fără diagnostic,
+Drug(s) Prescribed.,Medicament (e) prescris (e).,
+Test(s) Prescribed.,Test (e) prescris (e).,
+Procedure(s) Prescribed.,Procedură (proceduri) prescrise.,
+Counts Completed: {0},Număruri finalizate: {0},
+Patient Assessment,Evaluarea pacientului,
+Assessments,Evaluări,
+Heads (or groups) against which Accounting Entries are made and balances are maintained.,Heads (sau grupuri) față de care înregistrările contabile sunt făcute și soldurile sunt menținute.,
+Account Name,Numele Contului,
+Inter Company Account,Contul Companiei Inter,
+Parent Account,Contul părinte,
+Setting Account Type helps in selecting this Account in transactions.,Setarea Tipul de cont ajută în selectarea acest cont în tranzacții.,
+Chargeable,Taxabil/a,
+Rate at which this tax is applied,Rata la care se aplică acest impozit,
+Frozen,Blocat,
+"If the account is frozen, entries are allowed to restricted users.","În cazul în care contul este blocat, intrările sunt permite utilizatorilor restricționati.",
+Balance must be,Bilanţul trebuie să fie,
+Lft,Lft,
+Rgt,Rgt,
+Old Parent,Vechi mamă,
+Include in gross,Includeți în brut,
+Auditor,Auditor,
+Accounting Dimension,Dimensiunea contabilității,
+Dimension Name,Numele dimensiunii,
+Dimension Defaults,Valorile implicite ale dimensiunii,
+Accounting Dimension Detail,Detalii privind dimensiunea contabilității,
+Default Dimension,Dimensiunea implicită,
+Mandatory For Balance Sheet,Obligatoriu pentru bilanț,
+Mandatory For Profit and Loss Account,Obligatoriu pentru contul de profit și pierdere,
+Accounting Period,Perioadă Contabilă,
+Period Name,Numele perioadei,
+Closed Documents,Documente închise,
+Accounts Settings,Setări Conturi,
+Settings for Accounts,Setări pentru conturi,
+Make Accounting Entry For Every Stock Movement,Realizeaza Intrare de Contabilitate Pentru Fiecare Modificare a Stocului,
+Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Utilizatorii cu acest rol li se permite să stabilească în conturile înghețate și de a crea / modifica intrări contabile împotriva conturile înghețate,
+Determine Address Tax Category From,Determinați categoria de impozitare pe adresa de la,
+Over Billing Allowance (%),Indemnizație de facturare peste (%),
+Credit Controller,Controler de Credit,
+Check Supplier Invoice Number Uniqueness,Cec Furnizor Numărul facturii Unicitatea,
+Make Payment via Journal Entry,Efectuați o plată prin Jurnalul de intrare,
+Unlink Payment on Cancellation of Invoice,Plata unlink privind anularea facturii,
+Book Asset Depreciation Entry Automatically,Încărcarea automată a amortizării activelor din cont,
+Automatically Add Taxes and Charges from Item Tax Template,Adaugă automat impozite și taxe din șablonul de impozit pe articole,
+Automatically Fetch Payment Terms,Obțineți automat Termenii de plată,
+Show Payment Schedule in Print,Afișați programul de plată în Tipărire,
+Currency Exchange Settings,Setările de schimb valutar,
+Allow Stale Exchange Rates,Permiteți rate de schimb stale,
+Stale Days,Zilele stale,
+Report Settings,Setările raportului,
+Use Custom Cash Flow Format,Utilizați formatul fluxului de numerar personalizat,
+Allowed To Transact With,Permis pentru a tranzacționa cu,
+SWIFT number,Număr rapid,
+Branch Code,Codul filialei,
+Address and Contact,Adresa și Contact,
+Address HTML,Adresă HTML,
+Contact HTML,HTML Persoana de Contact,
+Data Import Configuration,Configurarea importului de date,
+Bank Transaction Mapping,Maparea tranzacțiilor bancare,
+Plaid Access Token,Token de acces la carouri,
+Company Account,Contul companiei,
+Account Subtype,Subtipul contului,
+Is Default Account,Este contul implicit,
+Is Company Account,Este un cont de companie,
+Party Details,Party Detalii,
+Account Details,Detalii cont,
+IBAN,IBAN,
+Bank Account No,Contul bancar nr,
+Integration Details,Detalii de integrare,
+Integration ID,ID de integrare,
+Last Integration Date,Ultima dată de integrare,
+Change this date manually to setup the next synchronization start date,Modificați această dată manual pentru a configura următoarea dată de început a sincronizării,
+Mask,Masca,
+Bank Account Subtype,Subtipul contului bancar,
+Bank Account Type,Tipul contului bancar,
+Bank Guarantee,Garantie bancara,
+Bank Guarantee Type,Tip de garanție bancară,
+Receiving,primire,
+Providing,Furnizarea,
+Reference Document Name,Numele documentului de referință,
+Validity in Days,Valabilitate în Zile,
+Bank Account Info,Informații despre contul bancar,
+Clauses and Conditions,Clauze și Condiții,
+Other Details,Alte detalii,
+Bank Guarantee Number,Numărul de garanție bancară,
+Name of Beneficiary,Numele beneficiarului,
+Margin Money,Marja de bani,
+Charges Incurred,Taxele incasate,
+Fixed Deposit Number,Numărul depozitului fix,
+Account Currency,Moneda cont,
+Select the Bank Account to reconcile.,Selectați contul bancar pentru a vă reconcilia.,
+Include Reconciled Entries,Includ intrările împăcat,
+Get Payment Entries,Participările de plată,
+Payment Entries,Intrările de plată,
+Update Clearance Date,Actualizare Clearance Data,
+Bank Reconciliation Detail,Detaliu reconciliere bancară,
+Cheque Number,Număr Cec,
+Cheque Date,Dată Cec,
+Statement Header Mapping,Afișarea antetului de rutare,
+Statement Headers,Antetele declarațiilor,
+Transaction Data Mapping,Transaction Data Mapping,
+Mapped Items,Elemente cartografiate,
+Bank Statement Settings Item,Elementul pentru setările declarației bancare,
+Mapped Header,Antet Cartografiat,
+Bank Header,Antetul băncii,
+Bank Statement Transaction Entry,Intrare tranzacție la declarația bancară,
+Bank Transaction Entries,Intrările de tranzacții bancare,
+New Transactions,Noi tranzacții,
+Match Transaction to Invoices,Tranzacționați tranzacția la facturi,
+Create New Payment/Journal Entry,Creați o nouă plată / intrare în jurnal,
+Submit/Reconcile Payments,Trimiteți / Recondiționați plățile,
+Matching Invoices,Facturi de potrivire,
+Payment Invoice Items,Elemente de factură de plată,
+Reconciled Transactions,Tranzacții Reconciliate,
+Bank Statement Transaction Invoice Item,Tranzacție de poziție bancară,
+Payment Description,Descrierea plății,
+Invoice Date,Data facturii,
+invoice,factura fiscala,
+Bank Statement Transaction Payment Item,Tranzacție de plată a tranzacției,
+outstanding_amount,suma restanta,
+Payment Reference,Referință de plată,
+Bank Statement Transaction Settings Item,Element pentru setările tranzacției din contul bancar,
+Bank Data,Date bancare,
+Mapped Data Type,Mapat tipul de date,
+Mapped Data,Date Cartografiate,
+Bank Transaction,Tranzacție bancară,
+ACC-BTN-.YYYY.-,ACC-BTN-.YYYY.-,
+Transaction ID,ID-ul de tranzacție,
+Unallocated Amount,Suma nealocată,
+Field in Bank Transaction,Câmp în tranzacția bancară,
+Column in Bank File,Coloana în fișierul bancar,
+Bank Transaction Payments,Plăți de tranzacții bancare,
+Control Action,Acțiune de control,
+Applicable on Material Request,Aplicabil la solicitarea materialului,
+Action if Annual Budget Exceeded on MR,Acțiune în cazul depășirii bugetului anual pe MR,
+Warn,Avertiza,
+Ignore,Ignora,
+Action if Accumulated Monthly Budget Exceeded on MR,Acțiune dacă bugetul lunar acumulat este depășit cu MR,
+Applicable on Purchase Order,Aplicabil pe comanda de aprovizionare,
+Action if Annual Budget Exceeded on PO,Acțiune în cazul în care bugetul anual depășește PO,
+Action if Accumulated Monthly Budget Exceeded on PO,Acțiune în cazul în care bugetul lunar acumulat este depășit cu PO,
+Applicable on booking actual expenses,Se aplică la rezervarea cheltuielilor reale,
+Action if Annual Budget Exceeded on Actual,Acțiune în cazul în care bugetul anual depășește suma actuală,
+Action if Accumulated Monthly Budget Exceeded on Actual,Acțiune în cazul în care bugetul lunar acumulat depășește valoarea reală,
+Budget Accounts,Conturile bugetare,
+Budget Account,Contul bugetar,
+Budget Amount,Buget Sumă,
+C-Form,Formular-C,
+ACC-CF-.YYYY.-,ACC-CF-.YYYY.-,
+C-Form No,Nr. formular-C,
+Received Date,Data primit,
+Quarter,Trimestru,
+I,eu,
+II,II,
+III,III,
+IV,IV,
+C-Form Invoice Detail,Detaliu factură formular-C,
+Invoice No,Nr Factura,
+Cash Flow Mapper,Cash Flow Mapper,
+Section Name,Numele secțiunii,
+Section Header,Secțiunea Header,
+Section Leader,Liderul secțiunii,
+e.g Adjustments for:,de ex. ajustări pentru:,
+Section Subtotal,Secțiunea Subtotal,
+Section Footer,Secțiunea Footer,
+Position,Poziţie,
+Cash Flow Mapping,Fluxul de numerar,
+Select Maximum Of 1,Selectați maxim de 1,
+Is Finance Cost,Este costul de finanțare,
+Is Working Capital,Este capitalul de lucru,
+Is Finance Cost Adjustment,Este ajustarea costurilor financiare,
+Is Income Tax Liability,Răspunderea pentru impozitul pe venit,
+Is Income Tax Expense,Cheltuielile cu impozitul pe venit,
+Cash Flow Mapping Accounts,Conturi de cartografiere a fluxurilor de numerar,
+account,Cont,
+Cash Flow Mapping Template,Formatul de cartografiere a fluxului de numerar,
+Cash Flow Mapping Template Details,Detaliile șablonului pentru fluxul de numerar,
+POS-CLO-,POS-CLO-,
+Custody,Custodie,
+Net Amount,Cantitate netă,
+Cashier Closing Payments,Plățile de închidere a caselor,
+Chart of Accounts Importer,Importatorul planului de conturi,
+Import Chart of Accounts from a csv file,Importați Graficul de conturi dintr-un fișier csv,
+Attach custom Chart of Accounts file,Atașați fișierul personalizat al graficului conturilor,
+Chart Preview,Previzualizare grafic,
+Chart Tree,Arbore grafic,
+Cheque Print Template,Format Imprimare Cec,
+Has Print Format,Are Format imprimare,
+Primary Settings,Setări primare,
+Cheque Size,Dimensiune  Cec,
+Regular,Regulat,
+Starting position from top edge,Poziția de la muchia superioară de pornire,
+Cheque Width,Lățime Cec,
+Cheque Height,Cheque Inaltime,
+Scanned Cheque,scanate cecului,
+Is Account Payable,Este cont de plati,
+Distance from top edge,Distanța de la marginea de sus,
+Distance from left edge,Distanța de la marginea din stânga,
+Message to show,Mesaj pentru a arăta,
+Date Settings,Setări Dată,
+Starting location from left edge,Punctul de plecare de la marginea din stânga,
+Payer Settings,Setări plătitorilor,
+Width of amount in word,Lățimea de cuvânt în sumă,
+Line spacing for amount in words,distanța dintre rânduri pentru suma în cuvinte,
+Amount In Figure,Suma în Figura,
+Signatory Position,Poziție semnatar,
+Closed Document,Document închis,
+Track separate Income and Expense for product verticals or divisions.,Urmăriți Venituri separat și cheltuieli verticale produse sau divizii.,
+Cost Center Name,Nume Centrul de Cost,
+Parent Cost Center,Părinte Cost Center,
+lft,LFT,
+rgt,RGT,
+Coupon Code,Codul promoțional,
+Coupon Name,Numele cuponului,
+"e.g. ""Summer Holiday 2019 Offer 20""",de ex. „Oferta de vacanță de vară 2019 20”,
+Coupon Type,Tip cupon,
+Promotional,promoționale,
+Gift Card,Card cadou,
+unique e.g. SAVE20  To be used to get discount,"unic, de exemplu, SAVE20 Pentru a fi utilizat pentru a obține reducere",
+Validity and Usage,Valabilitate și utilizare,
+Valid From,Valabil din,
+Valid Upto,Valid pana la,
+Maximum Use,Utilizare maximă,
+Used,Folosit,
+Coupon Description,Descrierea cuponului,
+Discounted Invoice,Factură redusă,
+Debit to,Debit la,
+Exchange Rate Revaluation,Reevaluarea cursului de schimb,
+Get Entries,Obțineți intrări,
+Exchange Rate Revaluation Account,Contul de reevaluare a cursului de schimb,
+Total Gain/Loss,Total câștig / pierdere,
+Balance In Account Currency,Soldul în moneda contului,
+Current Exchange Rate,Cursul de schimb curent,
+Balance In Base Currency,Soldul în moneda de bază,
+New Exchange Rate,Noul curs de schimb valutar,
+New Balance In Base Currency,Noul echilibru în moneda de bază,
+Gain/Loss,Gain / Pierdere,
+**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,**Anul fiscal** reprezintă un an financiar. Toate intrările contabile și alte tranzacții majore sunt monitorizate comparativ cu ** Anul fiscal **.,
+Year Name,An Denumire,
+"For e.g. 2012, 2012-13","De exemplu, 2012, 2012-13",
+Year Start Date,An Data începerii,
+Year End Date,Anul Data de încheiere,
+Companies,Companii,
+Auto Created,Crearea automată,
+Stock User,Stoc de utilizare,
+Fiscal Year Company,Anul fiscal companie,
+Debit Amount,Sumă Debit,
+Credit Amount,Suma de credit,
+Debit Amount in Account Currency,Sumă Debit în Monedă Cont,
+Credit Amount in Account Currency,Suma de credit în cont valutar,
+Voucher Detail No,Detaliu voucher Nu,
+Is Opening,Se deschide,
+Is Advance,Este Advance,
+To Rename,Pentru a redenumi,
+GST Account,Contul GST,
+CGST Account,Contul CGST,
+SGST Account,Contul SGST,
+IGST Account,Cont IGST,
+CESS Account,Cont CESS,
+Loan Start Date,Data de început a împrumutului,
+Loan Period (Days),Perioada de împrumut (zile),
+Loan End Date,Data de încheiere a împrumutului,
+Bank Charges,Taxe bancare,
+Short Term Loan Account,Cont de împrumut pe termen scurt,
+Bank Charges Account,Cont de taxe bancare,
+Accounts Receivable Credit Account,Conturi de credit de primit,
+Accounts Receivable Discounted Account,Conturi de primit cu reducere,
+Accounts Receivable Unpaid Account,Conturi de primit un cont neplătit,
+Item Tax Template,Șablon fiscal de articol,
+Tax Rates,Taxe de impozitare,
+Item Tax Template Detail,Detaliu de șablon fiscal,
+Entry Type,Tipul de intrare,
+Inter Company Journal Entry,Intrarea în Jurnalul Inter companiei,
+Bank Entry,Intrare bancară,
+Cash Entry,Cash intrare,
+Credit Card Entry,Card de credit intrare,
+Contra Entry,Contra intrare,
+Excise Entry,Intrare accize,
+Write Off Entry,Amortizare intrare,
+Opening Entry,Deschiderea de intrare,
+ACC-JV-.YYYY.-,ACC-JV-.YYYY.-,
+Accounting Entries,Înregistrări contabile,
+Total Debit,Total debit,
+Total Credit,Total credit,
+Difference (Dr - Cr),Diferența (Dr - Cr),
+Make Difference Entry,Realizeaza Intrare de Diferenta,
+Total Amount Currency,Suma totală Moneda,
+Total Amount in Words,Suma totală în cuvinte,
+Remark,Remarcă,
+Paid Loan,Imprumut platit,
+Inter Company Journal Entry Reference,Întreprindere de referință pentru intrarea în jurnal,
+Write Off Based On,Scrie Off bazat pe,
+Get Outstanding Invoices,Obtine Facturi Neachitate,
+Write Off Amount,Anulați suma,
+Printing Settings,Setări de imprimare,
+Pay To / Recd From,Pentru a plăti / Recd de la,
+Payment Order,Ordin de plată,
+Subscription Section,Secțiunea de abonamente,
+Journal Entry Account,Jurnal de cont intrare,
+Account Balance,Soldul contului,
+Party Balance,Balanța Party,
+Accounting Dimensions,Dimensiuni contabile,
+If Income or Expense,In cazul Veniturilor sau Cheltuielilor,
+Exchange Rate,Rata de schimb,
+Debit in Company Currency,Debit în Monedă Companie,
+Credit in Company Currency,Credit în companie valutar,
+Payroll Entry,Salarizare intrare,
+Employee Advance,Angajat Advance,
+Reference Due Date,Data de referință pentru referință,
+Loyalty Program Tier,Program de loialitate,
+Redeem Against,Răscumpărați împotriva,
+Expiry Date,Data expirării,
+Loyalty Point Entry Redemption,Punctul de răscumpărare a punctelor de loialitate,
+Redemption Date,Data de răscumpărare,
+Redeemed Points,Răscumpărate Puncte,
+Loyalty Program Name,Nume program de loialitate,
+Loyalty Program Type,Tip de program de loialitate,
+Single Tier Program,Program unic de nivel,
+Multiple Tier Program,Program multiplu,
+Customer Territory,Teritoriul clientului,
+Auto Opt In (For all customers),Oprire automată (pentru toți clienții),
+Collection Tier,Colecția Tier,
+Collection Rules,Regulile de colectare,
+Redemption,Răscumpărare,
+Conversion Factor,Factor de conversie,
+1 Loyalty Points = How much base currency?,1 Puncte de loialitate = Cât de multă monedă de bază?,
+Expiry Duration (in days),Termenul de expirare (în zile),
+Help Section,Secțiunea Ajutor,
+Loyalty Program Help,Programul de ajutor pentru loialitate,
+Loyalty Program Collection,Colecția de programe de loialitate,
+Tier Name,Denumirea nivelului,
+Minimum Total Spent,Suma totală cheltuită,
+Collection Factor (=1 LP),Factor de colectare (= 1 LP),
+For how much spent = 1 Loyalty Point,Pentru cât de mult a fost cheltuit = 1 punct de loialitate,
+Mode of Payment Account,Modul de cont de plăți,
+Default Account,Cont Implicit,
+Default account will be automatically updated in POS Invoice when this mode is selected.,Contul implicit va fi actualizat automat în factură POS când este selectat acest mod.,
+**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,** Lunar Distribuție ** vă ajută să distribuie bugetul / Target peste luni dacă aveți sezonier în afacerea dumneavoastră.,
+Distribution Name,Denumire Distribuție,
+Name of the Monthly Distribution,Numele de Distributie lunar,
+Monthly Distribution Percentages,Procente de distribuție lunare,
+Monthly Distribution Percentage,Lunar Procentaj Distribuție,
+Percentage Allocation,Alocarea procent,
+Create Missing Party,Creați Parte Lipsă,
+Create missing customer or supplier.,Creați client sau furnizor lipsă.,
+Opening Invoice Creation Tool Item,Deschiderea elementului instrumentului de creare a facturilor,
+Temporary Opening Account,Contul de deschidere temporar,
+Party Account,Party Account,
+Type of Payment,Tipul de plată,
+ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-,
+Receive,Primește,
+Internal Transfer,Transfer intern,
+Payment Order Status,Starea comenzii de plată,
+Payment Ordered,Plata a fost comandată,
+Payment From / To,Plata De la / la,
+Company Bank Account,Cont bancar al companiei,
+Party Bank Account,Cont bancar de partid,
+Account Paid From,Contul plătit De la,
+Account Paid To,Contul Plătite,
+Paid Amount (Company Currency),Plătit Suma (Compania de valuta),
+Received Amount,Sumă Primită,
+Received Amount (Company Currency),Suma primită (Moneda Companiei),
+Get Outstanding Invoice,Obțineți o factură excepțională,
+Payment References,Referințe de plată,
+Writeoff,Achita,
+Total Allocated Amount,Suma totală alocată,
+Total Allocated Amount (Company Currency),Suma totală alocată (Companie Moneda),
+Set Exchange Gain / Loss,Set Exchange Gain / Pierdere,
+Difference Amount (Company Currency),Diferența Sumă (Companie Moneda),
+Write Off Difference Amount,Diferență Sumă Piertdute,
+Deductions or Loss,Deduceri sau Pierderi,
+Payment Deductions or Loss,Deducerile de plată sau pierdere,
+Cheque/Reference Date,Cec/Dată de Referință,
+Payment Entry Deduction,Plată Deducerea intrare,
+Payment Entry Reference,Plată intrare de referință,
+Allocated,Alocat,
+Payment Gateway Account,Plata cont Gateway,
+Payment Account,Cont de plăți,
+Default Payment Request Message,Implicit solicita plata mesaj,
+PMO-,PMO-,
+Payment Order Type,Tipul ordinului de plată,
+Payment Order Reference,Instrucțiuni de plată,
+Bank Account Details,Detaliile contului bancar,
+Payment Reconciliation,Reconcilierea plată,
+Receivable / Payable Account,De încasat de cont / de plătit,
+Bank / Cash Account,Cont bancă / numerar,
+From Invoice Date,De la data facturii,
+To Invoice Date,Pentru a facturii Data,
+Minimum Invoice Amount,Factură cantitate minimă,
+Maximum Invoice Amount,Suma maxima Factură,
+System will fetch all the entries if limit value is zero.,Sistemul va prelua toate intrările dacă valoarea limită este zero.,
+Get Unreconciled Entries,Ia nereconciliate Entries,
+Unreconciled Payment Details,Nereconciliate Detalii de plată,
+Invoice/Journal Entry Details,Factura / Jurnalul Detalii intrari,
+Payment Reconciliation Invoice,Reconcilierea plata facturii,
+Invoice Number,Numar factura,
+Payment Reconciliation Payment,Reconciliere de plata,
+Reference Row,rândul de referință,
+Allocated amount,Suma alocată,
+Payment Request Type,Tip de solicitare de plată,
+Outward,Exterior,
+Inward,interior,
+ACC-PRQ-.YYYY.-,ACC-PRQ-.YYYY.-,
+Transaction Details,Detalii tranzacție,
+Amount in customer's currency,Suma în moneda clientului,
+Is a Subscription,Este un abonament,
+Transaction Currency,Operațiuni valutare,
+Subscription Plans,Planuri de abonament,
+SWIFT Number,Număr rapid,
+Recipient Message And Payment Details,Mesaj destinatar și Detalii de plată,
+Make Sales Invoice,Faceți Factură de Vânzare,
+Mute Email,Mute Email,
+payment_url,payment_url,
+Payment Gateway Details,Plata Gateway Detalii,
+Payment Schedule,Planul de plăți,
+Invoice Portion,Fracțiunea de facturi,
+Payment Amount,Plata Suma,
+Payment Term Name,Numele termenului de plată,
+Due Date Based On,Data de bază bazată pe,
+Day(s) after invoice date,Ziua (zilele) după data facturii,
+Day(s) after the end of the invoice month,Ziua (zilele) de la sfârșitul lunii facturii,
+Month(s) after the end of the invoice month,Luna (luni) după sfârșitul lunii facturii,
+Credit Days,Zile de Credit,
+Credit Months,Lunile de credit,
+Allocate Payment Based On Payment Terms,Alocați plata în funcție de condițiile de plată,
+"If this checkbox is checked, paid amount will be splitted and allocated as per the amounts in payment schedule against each payment term","Dacă această casetă de selectare este bifată, suma plătită va fi împărțită și alocată conform sumelor din programul de plată pentru fiecare termen de plată",
+Payment Terms Template Detail,Plata detaliilor privind termenii de plată,
+Closing Fiscal Year,Închiderea Anului Fiscal,
+Closing Account Head,Închidere Cont Principal,
+"The account head under Liability or Equity, in which Profit/Loss will be booked","Capul de cont sub răspunderea sau a capitalului propriu, în care Profit / Pierdere vor fi rezervate",
+POS Customer Group,Grup Clienți POS,
+POS Field,Câmpul POS,
+POS Item Group,POS Articol Grupa,
+Company Address,Adresă Companie,
+Update Stock,Actualizare stock,
+Ignore Pricing Rule,Ignora Regula Preturi,
+Applicable for Users,Aplicabil pentru utilizatori,
+Sales Invoice Payment,Vânzări factură de plată,
+Item Groups,Grupuri articol,
+Only show Items from these Item Groups,Afișați numai articole din aceste grupuri de articole,
+Customer Groups,Grupuri de clienți,
+Only show Customer of these Customer Groups,Afișați numai Clientul acestor grupuri de clienți,
+Write Off Account,Scrie Off cont,
+Write Off Cost Center,Scrie Off cost Center,
+Account for Change Amount,Contul pentru Schimbare Sumă,
+Taxes and Charges,Impozite și Taxe,
+Apply Discount On,Aplicați Discount pentru,
+POS Profile User,Utilizator de profil POS,
+Apply On,Se aplică pe,
+Price or Product Discount,Preț sau reducere produs,
+Apply Rule On Item Code,Aplicați regula pe codul articolului,
+Apply Rule On Item Group,Aplicați regula pe grupul de articole,
+Apply Rule On Brand,Aplicați regula pe marcă,
+Mixed Conditions,Condiții mixte,
+Conditions will be applied on all the selected items combined. ,Condițiile se vor aplica pe toate elementele selectate combinate.,
+Is Cumulative,Este cumulativ,
+Coupon Code Based,Bazat pe codul cuponului,
+Discount on Other Item,Reducere la alt articol,
+Apply Rule On Other,Aplicați regula pe alte,
+Party Information,Informații despre petreceri,
+Quantity and Amount,Cantitate și sumă,
+Min Qty,Min Cantitate,
+Max Qty,Max Cantitate,
+Min Amt,Amt min,
+Max Amt,Max Amt,
+Period Settings,Setări perioade,
+Margin,Margin,
+Margin Type,Tipul de marjă,
+Margin Rate or Amount,Rata de marjă sau Sumă,
+Price Discount Scheme,Schema de reducere a prețurilor,
+Rate or Discount,Tarif sau Discount,
+Discount Percentage,Procentul de Reducere,
+Discount Amount,Reducere Suma,
+For Price List,Pentru Lista de Preturi,
+Product Discount Scheme,Schema de reducere a produsului,
+Same Item,Același articol,
+Free Item,Articol gratuit,
+Threshold for Suggestion,Prag pentru sugestie,
+System will notify to increase or decrease quantity or amount ,Sistemul va notifica să crească sau să scadă cantitatea sau cantitatea,
+"Higher the number, higher the priority","Este mai mare numărul, mai mare prioritate",
+Apply Multiple Pricing Rules,Aplicați mai multe reguli privind prețurile,
+Apply Discount on Rate,Aplicați reducere la tarif,
+Validate Applied Rule,Validați regula aplicată,
+Rule Description,Descrierea regulii,
+Pricing Rule Help,Regula de stabilire a prețurilor de ajutor,
+Promotional Scheme Id,Codul promoțional ID,
+Promotional Scheme,Schema promoțională,
+Pricing Rule Brand,Marca de regulă a prețurilor,
+Pricing Rule Detail,Detaliu privind regula prețurilor,
+Child Docname,Numele documentului pentru copii,
+Rule Applied,Regula aplicată,
+Pricing Rule Item Code,Regula prețurilor Cod articol,
+Pricing Rule Item Group,Grupul de articole din regula prețurilor,
+Price Discount Slabs,Placi cu reducere de preț,
+Promotional Scheme Price Discount,Schema promoțională Reducere de preț,
+Product Discount Slabs,Placi cu reducere de produse,
+Promotional Scheme Product Discount,Schema promoțională Reducere de produs,
+Min Amount,Suma minima,
+Max Amount,Suma maximă,
+Discount Type,Tipul reducerii,
+ACC-PINV-.YYYY.-,ACC-PINV-.YYYY.-,
+Tax Withholding Category,Categoria de reținere fiscală,
+Edit Posting Date and Time,Editare postare Data și ora,
+Is Paid,Este platit,
+Is Return (Debit Note),Este Return (Nota de debit),
+Apply Tax Withholding Amount,Aplicați suma de reținere fiscală,
+Accounting Dimensions ,Dimensiuni contabile,
+Supplier Invoice Details,Furnizor Detalii factură,
+Supplier Invoice Date,Furnizor Data facturii,
+Return Against Purchase Invoice,Reveni Împotriva cumparare factură,
+Select Supplier Address,Selectați Furnizor Adresă,
+Contact Person,Persoană de contact,
+Select Shipping Address,Selectați adresa de expediere,
+Currency and Price List,Valută și lista de prețuri,
+Price List Currency,Lista de pret Valuta,
+Price List Exchange Rate,Lista de schimb valutar,
+Set Accepted Warehouse,Set depozit acceptat,
+Rejected Warehouse,Depozit Respins,
+Warehouse where you are maintaining stock of rejected items,Depozit în cazul în care se menține stocul de articole respinse,
+Raw Materials Supplied,Materii prime furnizate,
+Supplier Warehouse,Furnizor Warehouse,
+Pricing Rules,Reguli privind prețurile,
+Supplied Items,Articole furnizate,
+Total (Company Currency),Total (Company valutar),
+Net Total (Company Currency),Net total (Compania de valuta),
+Total Net Weight,Greutatea totală netă,
+Shipping Rule,Regula de transport maritim,
+Purchase Taxes and Charges Template,Achiziționa impozite și taxe Template,
+Purchase Taxes and Charges,Taxele de cumpărare și Taxe,
+Tax Breakup,Descărcarea de impozite,
+Taxes and Charges Calculation,Impozite și Taxe Calcul,
+Taxes and Charges Added (Company Currency),Impozite și Taxe adăugate (Compania de valuta),
+Taxes and Charges Deducted (Company Currency),Impozite și taxe deduse (Compania de valuta),
+Total Taxes and Charges (Company Currency),Total Impozite si Taxe (Compania valutar),
+Taxes and Charges Added,Impozite și Taxe Added,
+Taxes and Charges Deducted,Impozite și Taxe dedus,
+Total Taxes and Charges,Total Impozite și Taxe,
+Additional Discount,Discount suplimentar,
+Apply Additional Discount On,Aplicați Discount suplimentare La,
+Additional Discount Amount (Company Currency),Discount suplimentar Suma (companie de valuta),
+Additional Discount Percentage,Procent de reducere suplimentară,
+Additional Discount Amount,Suma de reducere suplimentară,
+Grand Total (Company Currency),Total general (Valuta Companie),
+Rounding Adjustment (Company Currency),Rotunjire ajustare (moneda companiei),
+Rounded Total (Company Currency),Rotunjite total (Compania de valuta),
+In Words (Company Currency),În cuvinte (Compania valutar),
+Rounding Adjustment,Ajustare Rotunjire,
+In Words,În cuvinte,
+Total Advance,Total de Advance,
+Disable Rounded Total,Dezactivati Totalul Rotunjit,
+Cash/Bank Account,Numerar/Cont Bancar,
+Write Off Amount (Company Currency),Scrie Off Suma (Compania de valuta),
+Set Advances and Allocate (FIFO),Setați avansuri și alocați (FIFO),
+Get Advances Paid,Obtine Avansurile Achitate,
+Advances,Avansuri,
+Terms,Termeni,
+Terms and Conditions1,Termeni și Conditions1,
+Group same items,Același grup de elemente,
+Print Language,Limba de imprimare,
+"Once set, this invoice will be on hold till the set date","Odată stabilită, această factură va fi reținută până la data stabilită",
+Credit To,De Creditat catre,
+Party Account Currency,Partidul cont valutar,
+Against Expense Account,Comparativ contului de cheltuieli,
+Inter Company Invoice Reference,Interfața de referință pentru interfața companiei,
+Is Internal Supplier,Este furnizor intern,
+Start date of current invoice's period,Data perioadei de factura de curent începem,
+End date of current invoice's period,Data de încheiere a perioadei facturii curente,
+Update Auto Repeat Reference,Actualizați referința de repetare automată,
+Purchase Invoice Advance,Factura de cumpărare în avans,
+Purchase Invoice Item,Factura de cumpărare Postul,
+Quantity and Rate,Cantitatea și rata,
+Received Qty,Cantitate primita,
+Accepted Qty,Cantitate acceptată,
+Rejected Qty,Cant. Respinsă,
+UOM Conversion Factor,Factorul de conversie UOM,
+Discount on Price List Rate (%),Reducere la Lista de preturi Rate (%),
+Price List Rate (Company Currency),Lista de prețuri Rate (Compania de valuta),
+Rate (Company Currency),Rata de (Compania de valuta),
+Amount (Company Currency),Sumă (monedă companie),
+Is Free Item,Este articol gratuit,
+Net Rate,Rata netă,
+Net Rate (Company Currency),Rata netă (companie de valuta),
+Net Amount (Company Currency),Suma netă (companie de valuta),
+Item Tax Amount Included in Value,Suma impozitului pe articol inclus în valoare,
+Landed Cost Voucher Amount,Costul Landed Voucher Suma,
+Raw Materials Supplied Cost,Costul materiilor prime livrate,
+Accepted Warehouse,Depozit Acceptat,
+Serial No,Nr. serie,
+Rejected Serial No,Respins de ordine,
+Expense Head,Beneficiar Cheltuiala,
+Is Fixed Asset,Este activ fix,
+Asset Location,Locația activelor,
+Deferred Expense,Cheltuieli amânate,
+Deferred Expense Account,Contul de cheltuieli amânate,
+Service Stop Date,Data de începere a serviciului,
+Enable Deferred Expense,Activați cheltuielile amânate,
+Service Start Date,Data de începere a serviciului,
+Service End Date,Data de încheiere a serviciului,
+Allow Zero Valuation Rate,Permiteți ratei de evaluare zero,
+Item Tax Rate,Rata de Impozitare Articol,
+Tax detail table fetched from item master as a string and stored in this field.\nUsed for Taxes and Charges,Taxa detaliu tabel preluat de la maestru articol ca un șir și stocate în acest domeniu.\n Folosit pentru Impozite și Taxe,
+Purchase Order Item,Comandă de aprovizionare Articol,
+Purchase Receipt Detail,Detaliu de primire a achiziției,
+Item Weight Details,Greutate Detalii articol,
+Weight Per Unit,Greutate pe unitate,
+Total Weight,Greutate totală,
+Weight UOM,Greutate UOM,
+Page Break,Page Break,
+Consider Tax or Charge for,Considerare Taxa sau Cost pentru,
+Valuation and Total,Evaluare și Total,
+Valuation,Evaluare,
+Add or Deduct,Adăugaţi sau deduceţi,
+Deduct,Deduce,
+On Previous Row Amount,La rândul precedent Suma,
+On Previous Row Total,Inapoi la rândul Total,
+On Item Quantity,Pe cantitatea articolului,
+Reference Row #,Reference Row #,
+Is this Tax included in Basic Rate?,Este acest fiscală inclusă în rata de bază?,
+"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","In cazul in care se bifeaza, suma taxelor va fi considerată ca fiind deja inclusa în Rata de Imprimare / Suma de Imprimare",
+Account Head,Titularul Contului,
+Tax Amount After Discount Amount,Suma taxa După Discount Suma,
+Item Wise Tax Detail ,Articolul Detaliu fiscal înțelept,
+"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.\n10. Add or Deduct: Whether you want to add or deduct the tax.","Șablon de impozitare standard care pot fi aplicate la toate tranzacțiile de cumpărare. Acest model poate conține lista de capete fiscale și, de asemenea, mai multe capete de cheltuieli, cum ar fi ""de transport"", ""asigurare"", ""manipulare"" etc. \n\n #### Notă \n\n Rata de impozitare pe care o definiți aici va fi rata de impozitare standard pentru toate Articole ** **. Dacă există articole ** **, care au preturi diferite, acestea trebuie să fie adăugate în ** Impozitul Postul ** masă în ** ** postul comandantului.\n\n #### Descrierea de coloane \n\n 1. Calcul Tip: \n - Acest lucru poate fi pe ** net total ** (care este suma cuantum de bază).\n - ** La rândul precedent Raport / Suma ** (pentru impozite sau taxe cumulative). Dacă selectați această opțiune, impozitul va fi aplicat ca procent din rândul anterior (în tabelul de impozitare) suma totală sau.\n - ** ** Real (după cum sa menționat).\n 2. Șeful cont: Registrul cont în care acest impozit va fi rezervat \n 3. Cost Center: În cazul în care taxa / taxa este un venit (cum ar fi de transport maritim) sau cheltuieli trebuie să se rezervat împotriva unui centru de cost.\n 4. Descriere: Descriere a taxei (care vor fi tipărite în facturi / citate).\n 5. Notă: Rata de Profit Brut.\n 6. Suma: suma taxei.\n 7. Total: total cumulat la acest punct.\n 8. Introduceți Row: Dacă bazat pe ""Înapoi Row Total"", puteți selecta numărul rând care vor fi luate ca bază pentru acest calcul (implicit este rândul precedent).\n 9. Luați în considerare Brut sau Taxa pentru: În această secțiune puteți specifica dacă taxa / taxa este doar pentru evaluare (nu o parte din total) sau numai pe total (nu adaugă valoare elementul) sau pentru ambele.\n 10. Adăugați sau deduce: Fie că doriți să adăugați sau deduce taxa.",
+Salary Component Account,Contul de salariu Componentă,
+Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Default cont bancar / numerar vor fi actualizate automat în Jurnalul de intrare a salariului când este selectat acest mod.,
+ACC-SINV-.YYYY.-,ACC-SINV-.YYYY.-,
+Include Payment (POS),Include de plată (POS),
+Offline POS Name,Offline Numele POS,
+Is Return (Credit Note),Este retur (nota de credit),
+Return Against Sales Invoice,Reveni Împotriva Vânzări factură,
+Update Billed Amount in Sales Order,Actualizați suma facturată în comandă de vânzări,
+Customer PO Details,Detalii PO pentru clienți,
+Customer's Purchase Order,Comandă clientului,
+Customer's Purchase Order Date,Data Comanda de Aprovizionare Client,
+Customer Address,Adresă Client,
+Shipping Address Name,Transport Adresa Nume,
+Company Address Name,Nume Companie,
+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 customer's base currency,Rata la care lista de prețuri moneda este convertit în valuta de bază a clientului,
+Set Source Warehouse,Set sursă depozit,
+Packing List,Lista de ambalare,
+Packed Items,Articole pachet,
+Product Bundle Help,Produs Bundle Ajutor,
+Time Sheet List,Listă de timp Sheet,
+Time Sheets,Foi de timp,
+Total Billing Amount,Suma totală de facturare,
+Sales Taxes and Charges Template,Impozite vânzări și șabloane Taxe,
+Sales Taxes and Charges,Taxele de vânzări și Taxe,
+Loyalty Points Redemption,Răscumpărarea punctelor de loialitate,
+Redeem Loyalty Points,Răscumpărați punctele de loialitate,
+Redemption Account,Cont de Răscumpărare,
+Redemption Cost Center,Centrul de cost de răscumpărare,
+In Words will be visible once you save the Sales Invoice.,În cuvinte va fi vizibil după salvarea facturii.,
+Allocate Advances Automatically (FIFO),Alocați avansuri automat (FIFO),
+Get Advances Received,Obtine Avansurile Primite,
+Base Change Amount (Company Currency),De schimbare a bazei Suma (Companie Moneda),
+Write Off Outstanding Amount,Scrie Off remarcabile Suma,
+Terms and Conditions Details,Termeni și condiții Detalii,
+Is Internal Customer,Este client intern,
+Is Discounted,Este redus,
+Unpaid and Discounted,Neplătit și redus,
+Overdue and Discounted,Întârziat și redus,
+Accounting Details,Detalii Contabilitate,
+Debit To,Debit Pentru,
+Is Opening Entry,Deschiderea este de intrare,
+C-Form Applicable,Formular-C aplicabil,
+Commission Rate (%),Rata de Comision (%),
+Sales Team1,Vânzări TEAM1,
+Against Income Account,Comparativ contului de venit,
+Sales Invoice Advance,Factura Vanzare Advance,
+Advance amount,Sumă în avans,
+Sales Invoice Item,Factură de vânzări Postul,
+Customer's Item Code,Cod Articol Client,
+Brand Name,Denumire marcă,
+Qty as per Stock UOM,Cantitate conform Stock UOM,
+Discount and Margin,Reducere și marja de profit,
+Rate With Margin,Rate cu marjă,
+Discount (%) on Price List Rate with Margin,Reducere (%) la rata de listă cu marjă,
+Rate With Margin (Company Currency),Rata cu marjă (moneda companiei),
+Delivered By Supplier,Livrate de Furnizor,
+Deferred Revenue,Venituri amânate,
+Deferred Revenue Account,Contul de venituri amânate,
+Enable Deferred Revenue,Activați venitul amânat,
+Stock Details,Stoc Detalii,
+Customer Warehouse (Optional),Depozit de client (opțional),
+Available Batch Qty at Warehouse,Cantitate lot disponibilă în depozit,
+Available Qty at Warehouse,Cantitate disponibilă în depozit,
+Delivery Note Item,Articol de nota de Livrare,
+Base Amount (Company Currency),Suma de bază (Companie Moneda),
+Sales Invoice Timesheet,Vânzări factură Pontaj,
+Time Sheet,Fișa de timp,
+Billing Hours,Ore de facturare,
+Timesheet Detail,Detalii pontaj,
+Tax Amount After Discount Amount (Company Currency),Suma impozitului pe urma Discount Suma (companie de valuta),
+Item Wise Tax Detail,Detaliu Taxa Avizata Articol,
+Parenttype,ParentType,
+"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","Șablon de impozitare standard, care pot fi aplicate la toate tranzacțiile de vânzare. Acest model poate conține lista de capete fiscale și, de asemenea, mai multe capete de cheltuieli / venituri, cum ar fi ""de transport"", ""asigurare"", ""manipulare"" etc. \n\n #### Notă \n\n vă Rata de impozitare defini aici va fi cota de impozitare standard pentru toate Articole ** **. Dacă există articole ** **, care au preturi diferite, acestea trebuie să fie adăugate în ** Impozitul Postul ** masă în ** ** postul comandantului.\n\n #### Descrierea de coloane \n\n 1. Calcul Tip: \n - Acest lucru poate fi pe ** net total ** (care este suma cuantum de bază).\n - ** La rândul precedent Raport / Suma ** (pentru impozite sau taxe cumulative). Dacă selectați această opțiune, impozitul va fi aplicat ca procent din rândul anterior (în tabelul de impozitare) suma totală sau.\n - ** ** Real (după cum sa menționat).\n 2. Șeful cont: Registrul cont în care acest impozit va fi rezervat \n 3. Cost Center: În cazul în care taxa / taxa este un venit (cum ar fi de transport maritim) sau cheltuieli trebuie să se rezervat împotriva unui centru de cost.\n 4. Descriere: Descriere a taxei (care vor fi tipărite în facturi / citate).\n 5. Notă: Rata de Profit Brut.\n 6. Suma: suma taxei.\n 7. Total: total cumulat la acest punct.\n 8. Introduceți Row: Dacă bazat pe ""Înapoi Row Total"", puteți selecta numărul rând care vor fi luate ca bază pentru acest calcul (implicit este rândul precedent).\n 9. Este Brut inclus în rata de bază ?: Dacă verifica acest lucru, înseamnă că acest impozit nu va fi arătată tabelul de mai jos articol, dar vor fi incluse în rata de bază din tabelul punctul principal. Acest lucru este util în cazul în care doriți dau un preț plat (cu toate taxele incluse) preț pentru clienți.",
+* Will be calculated in the transaction.,* Va fi calculat în cadrul tranzacției.,
+From No,De la nr,
+To No,Pentru a Nu,
+Is Company,Este compania,
+Current State,Starea curenta,
+Purchased,Cumparate,
+From Shareholder,De la acționar,
+From Folio No,Din Folio nr,
+To Shareholder,Pentru acționar,
+To Folio No,Pentru Folio nr,
+Equity/Liability Account,Contul de capitaluri proprii,
+Asset Account,Cont de active,
+(including),(inclusiv),
+ACC-SH-.YYYY.-,ACC-SH-.YYYY.-,
+Folio no.,Folio nr.,
+Address and Contacts,Adresa și Contacte,
+Contact List,Listă de contacte,
+Hidden list maintaining the list of contacts linked to Shareholder,Lista ascunsă menținând lista contactelor legate de acționar,
+Specify conditions to calculate shipping amount,Precizați condițiile de calcul cantitate de transport maritim,
+Shipping Rule Label,Regula de transport maritim Label,
+example: Next Day Shipping,exemplu: Next Day Shipping,
+Shipping Rule Type,Tipul regulii de transport,
+Shipping Account,Contul de transport maritim,
+Calculate Based On,Calculaţi pe baza,
+Fixed,Fix,
+Net Weight,Greutate netă,
+Shipping Amount,Suma de transport maritim,
+Shipping Rule Conditions,Condiții Regula de transport maritim,
+Restrict to Countries,Limitează la Țări,
+Valid for Countries,Valabil pentru țările,
+Shipping Rule Condition,Regula Condiții presetate,
+A condition for a Shipping Rule,O condiție pentru o normă de transport,
+From Value,Din Valoare,
+To Value,La valoarea,
+Shipping Rule Country,Regula de transport maritim Tara,
+Subscription Period,Perioada de abonament,
+Subscription Start Date,Data de începere a abonamentului,
+Cancelation Date,Data Anulării,
+Trial Period Start Date,Perioada de începere a perioadei de încercare,
+Trial Period End Date,Data de încheiere a perioadei de încercare,
+Current Invoice Start Date,Data de începere a facturii actuale,
+Current Invoice End Date,Data de încheiere a facturii actuale,
+Days Until Due,Zile Până la Termen,
+Number of days that the subscriber has to pay invoices generated by this subscription,Numărul de zile în care abonatul trebuie să plătească facturile generate de acest abonament,
+Cancel At End Of Period,Anulați la sfârșitul perioadei,
+Generate Invoice At Beginning Of Period,Generați factura la începutul perioadei,
+Plans,Planuri,
+Discounts,reduceri,
+Additional DIscount Percentage,Procent Discount Suplimentar,
+Additional DIscount Amount,Valoare discount-ului suplimentar,
+Subscription Invoice,Factura de abonament,
+Subscription Plan,Planul de abonament,
+Cost,Cost,
+Billing Interval,Intervalul de facturare,
+Billing Interval Count,Intervalul de facturare,
+"Number of intervals for the interval field e.g if Interval is 'Days' and Billing Interval Count is 3, invoices will be generated every 3 days","Numărul de intervale pentru câmpul intervalului, de exemplu, dacă Intervalul este &quot;Zile&quot; și Numărul de intervale de facturare este de 3, facturile vor fi generate la fiecare 3 zile",
+Payment Plan,Plan de plată,
+Subscription Plan Detail,Detaliile planului de abonament,
+Plan,Plan,
+Subscription Settings,Setările pentru abonament,
+Grace Period,Perioadă de grație,
+Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,Numărul de zile după expirarea datei facturii înainte de a anula abonamentul sau marcarea abonamentului ca neplătit,
+Prorate,Prorate,
+Tax Rule,Regula de impozitare,
+Tax Type,Tipul de impozitare,
+Use for Shopping Cart,Utilizați pentru Cos de cumparaturi,
+Billing City,Oraș de facturare,
+Billing County,Județ facturare,
+Billing State,Situatie facturare,
+Billing Zipcode,Cod poștal de facturare,
+Billing Country,Țara facturării,
+Shipping City,Transport Oraș,
+Shipping County,County transport maritim,
+Shipping State,Stat de transport maritim,
+Shipping Zipcode,Cod poștal de expediere,
+Shipping Country,Transport Tara,
+Tax Withholding Account,Contul de reținere fiscală,
+Tax Withholding Rates,Ratele de reținere fiscală,
+Rates,Tarife,
+Tax Withholding Rate,Rata reținerii fiscale,
+Single Transaction Threshold,Singurul prag de tranzacție,
+Cumulative Transaction Threshold,Valoarea cumulată a tranzacției,
+Agriculture Analysis Criteria,Criterii de analiză a agriculturii,
+Linked Doctype,Legate de Doctype,
+Water Analysis,Analiza apei,
+Soil Analysis,Analiza solului,
+Plant Analysis,Analiza plantelor,
+Fertilizer,Îngrăşământ,
+Soil Texture,Textura solului,
+Weather,Vreme,
+Agriculture Manager,Directorul Agriculturii,
+Agriculture User,Utilizator agricol,
+Agriculture Task,Agricultura,
+Task Name,Sarcina Nume,
+Start Day,Ziua de început,
+End Day,Sfârșitul zilei,
+Holiday Management,Gestionarea concediului,
+Ignore holidays,Ignorați sărbătorile,
+Previous Business Day,Ziua lucrătoare anterioară,
+Next Business Day,Ziua următoare de lucru,
+Urgent,De urgență,
+Crop,A decupa,
+Crop Name,Numele plantei,
+Scientific Name,Nume stiintific,
+"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Puteți defini toate sarcinile care trebuie îndeplinite pentru această recoltă aici. Câmpul de zi este folosit pentru a menționa ziua în care sarcina trebuie efectuată, 1 fiind prima zi, etc.",
+Crop Spacing,Decuparea culturii,
+Crop Spacing UOM,Distanțarea culturii UOM,
+Row Spacing,Spațierea rândului,
+Row Spacing UOM,Rândul de spațiu UOM,
+Perennial,peren,
+Biennial,Bienal,
+Planting UOM,Plantarea UOM,
+Planting Area,Zona de plantare,
+Yield UOM,Randamentul UOM,
+Materials Required,Materiale necesare,
+Produced Items,Articole produse,
+Produce,Legume şi fructe,
+Byproducts,produse secundare,
+Linked Location,Locație conectată,
+A link to all the Locations in which the Crop is growing,O legătură către toate locațiile în care cultura este în creștere,
+This will be day 1 of the crop cycle,Aceasta va fi prima zi a ciclului de cultură,
+ISO 8601 standard,Standardul ISO 8601,
+Cycle Type,Tip ciclu,
+Less than a year,Mai putin de un an,
+The minimum length between each plant in the field for optimum growth,Lungimea minimă dintre fiecare plantă din câmp pentru creștere optimă,
+The minimum distance between rows of plants for optimum growth,Distanța minimă dintre rânduri de plante pentru creștere optimă,
+Detected Diseases,Au detectat bolile,
+List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,"Lista bolilor detectate pe teren. Când este selectată, va adăuga automat o listă de sarcini pentru a face față bolii",
+Detected Disease,Boala detectată,
+LInked Analysis,Analiza analizată,
+Disease,boală,
+Tasks Created,Sarcini create,
+Common Name,Denumire Comună,
+Treatment Task,Sarcina de tratament,
+Treatment Period,Perioada de tratament,
+Fertilizer Name,Denumirea îngrășămintelor,
+Density (if liquid),Densitatea (dacă este lichidă),
+Fertilizer Contents,Conținutul de îngrășăminte,
+Fertilizer Content,Conținut de îngrășăminte,
+Linked Plant Analysis,Analiza plantelor conectate,
+Linked Soil Analysis,Analiza solului conectat,
+Linked Soil Texture,Textură de sol conectată,
+Collection Datetime,Data colecției,
+Laboratory Testing Datetime,Timp de testare a laboratorului,
+Result Datetime,Rezultat Datatime,
+Plant Analysis Criterias,Condiții de analiză a plantelor,
+Plant Analysis Criteria,Criterii de analiză a plantelor,
+Minimum Permissible Value,Valoarea minimă admisă,
+Maximum Permissible Value,Valoarea maximă admisă,
+Ca/K,Ca / K,
+Ca/Mg,Ca / Mg,
+Mg/K,Mg / K,
+(Ca+Mg)/K,(Ca + Mg) / K,
+Ca/(K+Ca+Mg),Ca / (K + Ca + Mg),
+Soil Analysis Criterias,Criterii de analiză a solului,
+Soil Analysis Criteria,Criterii de analiză a solului,
+Soil Type,Tipul de sol,
+Loamy Sand,Nisip argilos,
+Sandy Loam,Sandy Loam,
+Loam,Lut,
+Silt Loam,Silt Loam,
+Sandy Clay Loam,Sandy Clay Loam,
+Clay Loam,Argilos,
+Silty Clay Loam,Silty Clay Loam,
+Sandy Clay,Sandy Clay,
+Silty Clay,Lut de râu,
+Clay Composition (%),Compoziția de lut (%),
+Sand Composition (%),Compoziția nisipului (%),
+Silt Composition (%),Compoziția Silt (%),
+Ternary Plot,Ternar Plot,
+Soil Texture Criteria,Criterii de textură a solului,
+Type of Sample,Tipul de eșantion,
+Container,recipient,
+Origin,Origine,
+Collection Temperature ,Temperatura colecției,
+Storage Temperature,Temperatura de depozitare,
+Appearance,Aspect,
+Person Responsible,Persoană responsabilă,
+Water Analysis Criteria,Criterii de analiză a apei,
+Weather Parameter,Parametrul vremii,
+ACC-ASS-.YYYY.-,ACC-ASS-.YYYY.-,
+Asset Owner,Proprietarul de proprietar,
+Asset Owner Company,Societatea de proprietari de active,
+Custodian,Custode,
+Disposal Date,eliminare Data,
+Journal Entry for Scrap,Intrare Jurnal pentru Deșeuri,
+Available-for-use Date,Data disponibilă pentru utilizare,
+Calculate Depreciation,Calculează Amortizare,
+Allow Monthly Depreciation,Permite amortizarea lunară,
+Number of Depreciations Booked,Numărul de Deprecieri rezervat,
+Finance Books,Cărți de finanțare,
+Straight Line,Linie dreapta,
+Double Declining Balance,Dublu degresive,
+Manual,Manual,
+Value After Depreciation,Valoarea după amortizare,
+Total Number of Depreciations,Număr total de Deprecieri,
+Frequency of Depreciation (Months),Frecventa de amortizare (Luni),
+Next Depreciation Date,Data următoarei amortizări,
+Depreciation Schedule,Program de amortizare,
+Depreciation Schedules,Orarele de amortizare,
+Insurance details,Detalii de asigurare,
+Policy number,Numărul politicii,
+Insurer,Asiguratorul,
+Insured value,Valoarea asigurată,
+Insurance Start Date,Data de începere a asigurării,
+Insurance End Date,Data de încheiere a asigurării,
+Comprehensive Insurance,Asigurare completă,
+Maintenance Required,Mentenanță Necesară,
+Check if Asset requires Preventive Maintenance or Calibration,Verificați dacă activul necesită întreținere preventivă sau calibrare,
+Booked Fixed Asset,Carte imobilizată rezervată,
+Purchase Receipt Amount,Suma chitanței de cumpărare,
+Default Finance Book,Cartea de finanțare implicită,
+Quality Manager,Manager de calitate,
+Asset Category Name,Nume activ Categorie,
+Depreciation Options,Opțiunile de amortizare,
+Enable Capital Work in Progress Accounting,Activați activitatea de capital în contabilitate în curs,
+Finance Book Detail,Detaliile cărții de finanțe,
+Asset Category Account,Cont activ Categorie,
+Fixed Asset Account,Cont activ fix,
+Accumulated Depreciation Account,Cont Amortizarea cumulată,
+Depreciation Expense Account,Contul de amortizare de cheltuieli,
+Capital Work In Progress Account,Activitatea de capital în curs de desfășurare,
+Asset Finance Book,Cartea de finanțare a activelor,
+Written Down Value,Valoarea scrise în jos,
+Expected Value After Useful Life,Valoarea așteptată după viață utilă,
+Rate of Depreciation,Rata de depreciere,
+In Percentage,În procent,
+Maintenance Team,Echipă de Mentenanță,
+Maintenance Manager Name,Nume Manager Mentenanță,
+Maintenance Tasks,Sarcini de Mentenanță,
+Manufacturing User,Producție de utilizare,
+Asset Maintenance Log,Jurnalul de întreținere a activelor,
+ACC-AML-.YYYY.-,ACC-CSB-.YYYY.-,
+Maintenance Type,Tip Mentenanta,
+Maintenance Status,Stare Mentenanta,
+Planned,Planificat,
+Has Certificate ,Are certificat,
+Certificate,Certificat,
+Actions performed,Acțiuni efectuate,
+Asset Maintenance Task,Activitatea de întreținere a activelor,
+Maintenance Task,Activitate Mentenanță,
+Preventive Maintenance,Mentenanță preventivă,
+Calibration,Calibrare,
+2 Yearly,2 Anual,
+Certificate Required,Certificat necesar,
+Assign to Name,Atribuiți la Nume,
+Next Due Date,Data următoare,
+Last Completion Date,Ultima dată de finalizare,
+Asset Maintenance Team,Echipa de întreținere a activelor,
+Maintenance Team Name,Nume Echipă de Mentenanță,
+Maintenance Team Members,Membri Echipă de Mentenanță,
+Purpose,Scopul,
+Stock Manager,Stock Manager,
+Asset Movement Item,Element de mișcare a activelor,
+Source Location,Locația sursei,
+From Employee,Din Angajat,
+Target Location,Locația țintă,
+To Employee,Pentru angajat,
+Asset Repair,Repararea activelor,
+ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-,
+Failure Date,Dată de nerespectare,
+Assign To Name,Alocați nume,
+Repair Status,Stare de reparare,
+Error Description,Descrierea erorii,
+Downtime,downtime,
+Repair Cost,Costul reparațiilor,
+Manufacturing Manager,Manager de Producție,
+Current Asset Value,Valoarea activului curent,
+New Asset Value,Valoare nouă a activelor,
+Make Depreciation Entry,Asigurați-vă Amortizarea Intrare,
+Finance Book Id,Numărul cărții de credit,
+Location Name,Numele locatiei,
+Parent Location,Locația părintească,
+Is Container,Este Container,
+Check if it is a hydroponic unit,Verificați dacă este o unitate hidroponică,
+Location Details,Detalii despre locație,
+Latitude,Latitudine,
+Longitude,Longitudine,
+Area,Zonă,
+Area UOM,Zona UOM,
+Tree Details,copac Detalii,
+Maintenance Team Member,Membru Echipă de Mentenanță,
+Team Member,Membru al echipei,
+Maintenance Role,Rol de Mentenanță,
+Buying Settings,Configurări cumparare,
+Settings for Buying Module,Setări pentru cumparare Modulul,
+Supplier Naming By,Furnizor de denumire prin,
+Default Supplier Group,Grupul prestabilit de furnizori,
+Default Buying Price List,Lista de POrețuri de Cumparare Implicita,
+Backflush Raw Materials of Subcontract Based On,Materiile de bază din substratul bazat pe,
+Material Transferred for Subcontract,Material transferat pentru subcontractare,
+Over Transfer Allowance (%),Indemnizație de transfer peste (%),
+Percentage you are allowed to transfer more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to transfer 110 units.,"Procentaj pe care vi se permite să transferați mai mult în raport cu cantitatea comandată. De exemplu: Dacă ați comandat 100 de unități. iar alocația dvs. este de 10%, atunci vi se permite să transferați 110 unități.",
+PUR-ORD-.YYYY.-,PUR-ORD-.YYYY.-,
+Get Items from Open Material Requests,Obține elemente din materiale Cereri deschide,
+Fetch items based on Default Supplier.,Obțineți articole pe baza furnizorului implicit.,
+Required By,Cerute de,
+Order Confirmation No,Confirmarea nr,
+Order Confirmation Date,Data de confirmare a comenzii,
+Customer Mobile No,Client Mobile Nu,
+Customer Contact Email,Contact Email client,
+Set Target Warehouse,Stabilește Depozitul țintă,
+Sets 'Warehouse' in each row of the Items table.,Setează „Depozit” în fiecare rând al tabelului Elemente.,
+Supply Raw Materials,Aprovizionarea cu materii prime,
+Purchase Order Pricing Rule,Regula de preț a comenzii de achiziție,
+Set Reserve Warehouse,Set Rezerva Depozit,
+In Words will be visible once you save the Purchase Order.,În cuvinte va fi vizibil după ce a salva Ordinul de cumparare.,
+Advance Paid,Avans plătit,
+Tracking,Urmărirea,
+% Billed,% Facurat,
+% Received,% Primit,
+Ref SQ,Ref SQ,
+Inter Company Order Reference,Referință de comandă între companii,
+Supplier Part Number,Furnizor Număr,
+Billed Amt,Suma facturată,
+Warehouse and Reference,Depozit și Referință,
+To be delivered to customer,Pentru a fi livrat clientului,
+Material Request Item,Material Cerere Articol,
+Supplier Quotation Item,Furnizor ofertă Articol,
+Against Blanket Order,Împotriva ordinului pătură,
+Blanket Order,Ordinul de ștergere,
+Blanket Order Rate,Rata de comandă a plicului,
+Returned Qty,Cant. Returnată,
+Purchase Order Item Supplied,Comandă de aprovizionare Articol Livrat,
+BOM Detail No,Detaliu BOM nr.,
+Stock Uom,Stoc UOM,
+Raw Material Item Code,Cod Articol Materie Prima,
+Supplied Qty,Furnizat Cantitate,
+Purchase Receipt Item Supplied,Primirea de cumpărare Articol Livrat,
+Current Stock,Stoc curent,
+PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-,
+For individual supplier,Pentru furnizor individual,
+Link to Material Requests,Link către cereri de materiale,
+Message for Supplier,Mesaj pentru Furnizor,
+Request for Quotation Item,Articol Cerere de Oferta,
+Required Date,Data de livrare ceruta,
+Request for Quotation Supplier,Furnizor Cerere de Ofertă,
+Send Email,Trimiteți-ne email,
+Quote Status,Citat Stare,
+Download PDF,descarcă PDF,
+Supplier of Goods or Services.,Furnizor de bunuri sau servicii.,
+Name and Type,Numele și tipul,
+SUP-.YYYY.-,SUP-.YYYY.-,
+Default Bank Account,Cont Bancar Implicit,
+Is Transporter,Este Transporter,
+Represents Company,Reprezintă Compania,
+Supplier Type,Furnizor Tip,
+Allow Purchase Invoice Creation Without Purchase Order,Permiteți crearea facturii de cumpărare fără comandă de achiziție,
+Allow Purchase Invoice Creation Without Purchase Receipt,Permiteți crearea facturii de cumpărare fără chitanță de cumpărare,
+Warn RFQs,Aflați RFQ-urile,
+Warn POs,Avertizează PO-urile,
+Prevent RFQs,Preveniți RFQ-urile,
+Prevent POs,Preveniți PO-urile,
+Billing Currency,Moneda de facturare,
+Default Payment Terms Template,Șablonul Termenii de plată standard,
+Block Supplier,Furnizorul de blocuri,
+Hold Type,Tineți tip,
+Leave blank if the Supplier is blocked indefinitely,Lăsați necompletat dacă Furnizorul este blocat pe o perioadă nedeterminată,
+Default Payable Accounts,Implicit conturi de plătit,
+Mention if non-standard payable account,Menționați dacă contul de plată non-standard,
+Default Tax Withholding Config,Config,
+Supplier Details,Detalii furnizor,
+Statutory info and other general information about your Supplier,Info statutar și alte informații generale despre dvs. de Furnizor,
+PUR-SQTN-.YYYY.-,PUR-SQTN-.YYYY.-,
+Supplier Address,Furnizor Adresa,
+Link to material requests,Link la cererile de materiale,
+Rounding Adjustment (Company Currency,Rotunjire ajustare (moneda companiei,
+Auto Repeat Section,Se repetă secțiunea Auto,
+Is Subcontracted,Este subcontractată,
+Lead Time in days,Timp Pistă în zile,
+Supplier Score,Scorul furnizorului,
+Indicator Color,Indicator Culoare,
+Evaluation Period,Perioada de evaluare,
+Per Week,Pe saptamana,
+Per Month,Pe luna,
+Per Year,Pe an,
+Scoring Setup,Punctul de configurare,
+Weighting Function,Funcție de ponderare,
+"Scorecard variables can be used, as well as:\n{total_score} (the total score from that period),\n{period_number} (the number of periods to present day)\n","Variabilele caracterelor pot fi utilizate, precum și: {total_score} (scorul total din acea perioadă), {period_number} (numărul de perioade până în prezent)",
+Scoring Standings,Puncte de scor,
+Criteria Setup,Setarea criteriilor,
+Load All Criteria,Încărcați toate criteriile,
+Scoring Criteria,Criterii de evaluare,
+Scorecard Actions,Caracteristicile Scorecard,
+Warn for new Request for Quotations,Avertizare pentru o nouă solicitare de ofertă,
+Warn for new Purchase Orders,Avertizați pentru comenzi noi de achiziție,
+Notify Supplier,Notificați Furnizor,
+Notify Employee,Notificați angajatul,
+Supplier Scorecard Criteria,Criteriile Scorecard pentru furnizori,
+Criteria Name,Numele de criterii,
+Max Score,Scor maxim,
+Criteria Formula,Criterii Formula,
+Criteria Weight,Criterii Greutate,
+Supplier Scorecard Period,Perioada de evaluare a furnizorului,
+PU-SSP-.YYYY.-,PU-SSP-.YYYY.-,
+Period Score,Scorul perioadei,
+Calculations,Calculele,
+Criteria,criterii,
+Variables,variabile,
+Supplier Scorecard Setup,Setarea Scorecard pentru furnizori,
+Supplier Scorecard Scoring Criteria,Criteriile de evaluare a Scorecard-ului furnizorului,
+Score,Scor,
+Supplier Scorecard Scoring Standing,Scorecard pentru Scorecard furnizor,
+Standing Name,Numele permanent,
+Purple,Violet,
+Yellow,Galben,
+Orange,portocale,
+Min Grade,Gradul minim,
+Max Grade,Max Grad,
+Warn Purchase Orders,Avertizați comenzile de cumpărare,
+Prevent Purchase Orders,Împiedicați comenzile de achiziție,
+Employee ,Angajat,
+Supplier Scorecard Scoring Variable,Scorul variabil al scorului de performanță al furnizorului,
+Variable Name,Numele variabil,
+Parameter Name,Nume parametru,
+Supplier Scorecard Standing,Graficul Scorecard pentru furnizori,
+Notify Other,Notificați alta,
+Supplier Scorecard Variable,Variabila tabelului de variabile pentru furnizori,
+Call Log,Jurnal de Apel,
+Received By,Primit de,
+Caller Information,Informații despre apelant,
+Contact Name,Nume Persoana de Contact,
+Lead ,Conduce,
+Lead Name,Nume Pistă,
+Ringing,țiuit,
+Missed,Pierdute,
+Call Duration in seconds,Durata apelului în câteva secunde,
+Recording URL,Înregistrare URL,
+Communication Medium,Comunicare Mediu,
+Communication Medium Type,Tip mediu de comunicare,
+Voice,Voce,
+Catch All,Prindele pe toate,
+"If there is no assigned timeslot, then communication will be handled by this group","Dacă nu există un interval de timp alocat, comunicarea va fi gestionată de acest grup",
+Timeslots,Intervale de timp,
+Communication Medium Timeslot,Timeslot mediu de comunicare,
+Employee Group,Grupul de angajați,
+Appointment,Programare,
+Scheduled Time,Timpul programat,
+Unverified,neverificat,
+Customer Details,Detalii Client,
+Phone Number,Numar de telefon,
+Skype ID,ID Skype,
+Linked Documents,Documente legate,
+Appointment With,Programare cu,
+Calendar Event,Calendar Eveniment,
+Appointment Booking Settings,Setări rezervare numire,
+Enable Appointment Scheduling,Activați programarea programării,
+Agent Details,Detalii agent,
+Availability Of Slots,Disponibilitatea sloturilor,
+Number of Concurrent Appointments,Numărul de întâlniri simultane,
+Agents,agenţi,
+Appointment Details,Detalii despre numire,
+Appointment Duration (In Minutes),Durata numirii (în proces-verbal),
+Notify Via Email,Notificați prin e-mail,
+Notify customer and agent via email on the day of the appointment.,Notificați clientul și agentul prin e-mail în ziua programării.,
+Number of days appointments can be booked in advance,Numărul de întâlniri de zile poate fi rezervat în avans,
+Success Settings,Setări de succes,
+Success Redirect URL,Adresa URL de redirecționare,
+"Leave blank for home.\nThis is relative to site URL, for example ""about"" will redirect to ""https://yoursitename.com/about""","Lăsați gol pentru casă. Aceasta este relativă la adresa URL a site-ului, de exemplu „despre” se va redirecționa la „https://yoursitename.com/about”",
+Appointment Booking Slots,Rezervare pentru sloturi de rezervare,
+Day Of Week,Zi a Săptămânii,
+From Time ,Din Time,
+Campaign Email Schedule,Program de e-mail al campaniei,
+Send After (days),Trimite După (zile),
+Signed,Semnat,
+Party User,Utilizator de petreceri,
+Unsigned,Nesemnat,
+Fulfilment Status,Starea de îndeplinire,
+N/A,N / A,
+Unfulfilled,neîmplinit,
+Partially Fulfilled,Parțial îndeplinite,
+Fulfilled,Fulfilled,
+Lapsed,caducă,
+Contract Period,Perioada contractuala,
+Signee Details,Signee Detalii,
+Signee,Signee,
+Signed On,Signed On,
+Contract Details,Detaliile contractului,
+Contract Template,Model de contract,
+Contract Terms,Termenii contractului,
+Fulfilment Details,Detalii de execuție,
+Requires Fulfilment,Necesită îndeplinirea,
+Fulfilment Deadline,Termenul de îndeplinire,
+Fulfilment Terms,Condiții de îndeplinire,
+Contract Fulfilment Checklist,Lista de verificare a executării contului,
+Requirement,Cerinţă,
+Contract Terms and Conditions,Termeni și condiții contractuale,
+Fulfilment Terms and Conditions,Condiții și condiții de îndeplinire,
+Contract Template Fulfilment Terms,Termenii de îndeplinire a modelului de contract,
+Email Campaign,Campania de e-mail,
+Email Campaign For ,Campanie prin e-mail,
+Lead is an Organization,Pista este o Organizație,
+CRM-LEAD-.YYYY.-,CRM-LEAD-.YYYY.-,
+Person Name,Nume persoană,
+Lost Quotation,ofertă pierdută,
+Interested,Interesat,
+Converted,Transformat,
+Do Not Contact,Nu contactati,
+From Customer,De la Client,
+Campaign Name,Denumire campanie,
+Follow Up,Urmare,
+Next Contact By,Următor Contact Prin,
+Next Contact Date,Următor Contact Data,
+Ends On,Se termină pe,
+Address & Contact,Adresă și contact,
+Mobile No.,Numar de mobil,
+Lead Type,Tip Pistă,
+Channel Partner,Partner Canal,
+Consultant,Consultant,
+Market Segment,Segmentul de piață,
+Industry,Industrie,
+Request Type,Tip Cerere,
+Product Enquiry,Intrebare produs,
+Request for Information,Cerere de informații,
+Suggestions,Sugestii,
+Blog Subscriber,Abonat blog,
+LinkedIn Settings,Setări LinkedIn,
+Company ID,ID-ul companiei,
+OAuth Credentials,Acreditări OAuth,
+Consumer Key,Cheia consumatorului,
+Consumer Secret,Secretul consumatorului,
+User Details,Detalii utilizator,
+Person URN,Persoana URN,
+Session Status,Starea sesiunii,
+Lost Reason Detail,Detaliu ratiune pierduta,
+Opportunity Lost Reason,Motivul pierdut din oportunitate,
+Potential Sales Deal,Oferta potențiale Vânzări,
+CRM-OPP-.YYYY.-,CRM-OPP-.YYYY.-,
+Opportunity From,Oportunitate de la,
+Customer / Lead Name,Client / Nume Principal,
+Opportunity Type,Tip de oportunitate,
+Converted By,Convertit de,
+Sales Stage,Stadiu Vânzări,
+Lost Reason,Motiv Pierdere,
+Expected Closing Date,Data de închidere preconizată,
+To Discuss,Pentru a discuta,
+With Items,Cu articole,
+Probability (%),Probabilitate (%),
+Contact Info,Informaţii Persoana de Contact,
+Customer / Lead Address,Client / Adresa principala,
+Contact Mobile No,Nr. Mobil Persoana de Contact,
+Enter name of campaign if source of enquiry is campaign,Introduceți numele de campanie dacă sursa de anchetă este campanie,
+Opportunity Date,Oportunitate Data,
+Opportunity Item,Oportunitate Articol,
+Basic Rate,Rată elementară,
+Stage Name,Nume de Scenă,
+Social Media Post,Postare pe rețelele sociale,
+Post Status,Stare postare,
+Posted,Postat,
+Share On,Distribuie pe,
+Twitter,Stare de nervozitate,
+LinkedIn,LinkedIn,
+Twitter Post Id,Codul postării pe Twitter,
+LinkedIn Post Id,Cod postare LinkedIn,
+Tweet,Tweet,
+Twitter Settings,Setări Twitter,
+API Secret Key,Cheia secretă API,
+Term Name,Nume termen,
+Term Start Date,Termenul Data de începere,
+Term End Date,Termenul Data de încheiere,
+Academics User,Utilizator cadru pedagogic,
+Academic Year Name,Nume An Universitar,
+Article,Articol,
+LMS User,Utilizator LMS,
+Assessment Criteria Group,Grup de criterii de evaluare,
+Assessment Group Name,Numele grupului de evaluare,
+Parent Assessment Group,Grup părinte de evaluare,
+Assessment Name,Nume evaluare,
+Grading Scale,Scala de notare,
+Examiner,Examinator,
+Examiner Name,Nume examinator,
+Supervisor,supraveghetor,
+Supervisor Name,Nume supervizor,
+Evaluate,A evalua,
+Maximum Assessment Score,Scor maxim de evaluare,
+Assessment Plan Criteria,Criterii Plan de evaluare,
+Maximum Score,Scor maxim,
+Result,Rezultat,
+Total Score,Scorul total,
+Grade,calitate,
+Assessment Result Detail,Detalii rezultat evaluare,
+Assessment Result Tool,Instrument de Evaluare Rezultat,
+Result HTML,rezultat HTML,
+Content Activity,Activitate de conținut,
+Last Activity ,Ultima activitate,
+Content Question,Întrebare de conținut,
+Question Link,Link de întrebări,
+Course Name,Numele cursului,
+Topics,Subiecte,
+Hero Image,Imaginea eroului,
+Default Grading Scale,Scale Standard Standard folosit,
+Education Manager,Director de educație,
+Course Activity,Activitate de curs,
+Course Enrollment,Înscriere la curs,
+Activity Date,Data activității,
+Course Assessment Criteria,Criterii de evaluare a cursului,
+Weightage,Weightage,
+Course Content,Conținutul cursului,
+Quiz,chestionare,
+Program Enrollment,programul de înscriere,
+Enrollment Date,Data de inscriere,
+Instructor Name,Nume instructor,
+EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-,
+Course Scheduling Tool,Instrument curs de programare,
+Course Start Date,Data începerii cursului,
+To TIme,La timp,
+Course End Date,Desigur Data de încheiere,
+Course Topic,Subiectul cursului,
+Topic,Subiect,
+Topic Name,Nume subiect,
+Education Settings,Setări educaționale,
+Current Academic Year,Anul academic curent,
+Current Academic Term,Termen academic actual,
+Attendance Freeze Date,Data de înghețare a prezenței,
+Validate Batch for Students in Student Group,Validați lotul pentru elevii din grupul de studenți,
+"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Pentru grupul de studenți bazat pe loturi, lotul student va fi validat pentru fiecare student din înscrierea în program.",
+Validate Enrolled Course for Students in Student Group,Validați cursul înscris pentru elevii din grupul de studenți,
+"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.","Pentru grupul de studenți bazat pe cursuri, cursul va fi validat pentru fiecare student din cursurile înscrise în înscrierea în program.",
+Make Academic Term Mandatory,Asigurați-obligatoriu termenul academic,
+"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Dacă este activată, domeniul Academic Term va fi obligatoriu în Instrumentul de înscriere în program.",
+Skip User creation for new Student,Omiteți crearea utilizatorului pentru noul student,
+"By default, a new User is created for every new Student. If enabled, no new User will be created when a new Student is created.","În mod implicit, este creat un nou utilizator pentru fiecare student nou. Dacă este activat, nu va fi creat niciun utilizator nou atunci când este creat un nou student.",
+Instructor Records to be created by,Instructor de înregistrări care urmează să fie create de către,
+Employee Number,Numar angajat,
+Fee Category,Taxă Categorie,
+Fee Component,Taxa de Component,
+Fees Category,Taxele de Categoria,
+Fee Schedule,Taxa de Program,
+Fee Structure,Structura Taxa de,
+EDU-FSH-.YYYY.-,EDU-FSH-.YYYY.-,
+Fee Creation Status,Starea de creare a taxelor,
+In Process,În procesul de,
+Send Payment Request Email,Trimiteți e-mail de solicitare de plată,
+Student Category,Categoria de student,
+Fee Breakup for each student,Taxă pentru fiecare student,
+Total Amount per Student,Suma totală pe student,
+Institution,Instituţie,
+Fee Schedule Program,Programul programului de plăți,
+Student Batch,Lot de student,
+Total Students,Total studenți,
+Fee Schedule Student Group,Taxă Schedule Student Group,
+EDU-FST-.YYYY.-,EDU-FST-.YYYY.-,
+EDU-FEE-.YYYY.-,EDU-FEE-.YYYY.-,
+Include Payment,Includeți plata,
+Send Payment Request,Trimiteți Cerere de Plată,
+Student Details,Detalii studențești,
+Student Email,Student Email,
+Grading Scale Name,Standard Nume Scala,
+Grading Scale Intervals,Intervale de notare Scala,
+Intervals,intervale,
+Grading Scale Interval,Clasificarea Scala Interval,
+Grade Code,Cod grad,
+Threshold,Prag,
+Grade Description,grad Descriere,
+Guardian,gardian,
+Guardian Name,Nume tutore,
+Alternate Number,Număr alternativ,
+Occupation,Ocupaţie,
+Work Address,Adresa de,
+Guardian Of ,Guardian Of,
+Students,Elevi,
+Guardian Interests,Guardian Interese,
+Guardian Interest,Interes tutore,
+Interest,Interes,
+Guardian Student,Guardian Student,
+EDU-INS-.YYYY.-,EDU-INS-.YYYY.-,
+Instructor Log,Jurnalul instructorului,
+Other details,Alte detalii,
+Option,Opțiune,
+Is Correct,Este corect,
+Program Name,Numele programului,
+Program Abbreviation,Abreviere de program,
+Courses,cursuri,
+Is Published,Este publicat,
+Allow Self Enroll,Permiteți înscrierea de sine,
+Is Featured,Este prezentat,
+Intro Video,Introducere video,
+Program Course,Curs Program,
+School House,School House,
+Boarding Student,Student de internare,
+Check this if the Student is residing at the Institute's Hostel.,Verificați dacă studentul este rezident la Hostelul Institutului.,
+Walking,mers,
+Institute's Bus,Biblioteca Institutului,
+Public Transport,Transport public,
+Self-Driving Vehicle,Vehicul cu autovehicul,
+Pick/Drop by Guardian,Pick / Drop de Guardian,
+Enrolled courses,Cursuri înscrise,
+Program Enrollment Course,Curs de înscriere la curs,
+Program Enrollment Fee,Programul de înscriere Taxa,
+Program Enrollment Tool,Programul Instrumentul de înscriere,
+Get Students From,Elevii de la a lua,
+Student Applicant,Solicitantul elev,
+Get Students,Studenți primi,
+Enrollment Details,Detalii de înscriere,
+New Program,programul nou,
+New Student Batch,Noul lot de studenți,
+Enroll Students,Studenți Enroll,
+New Academic Year,Anul universitar nou,
+New Academic Term,Termen nou academic,
+Program Enrollment Tool Student,Programul de înscriere Instrumentul Student,
+Student Batch Name,Nume elev Lot,
+Program Fee,Taxa de program,
+Question,Întrebare,
+Single Correct Answer,Un singur răspuns corect,
+Multiple Correct Answer,Răspuns corect multiplu,
+Quiz Configuration,Configurarea testului,
+Passing Score,Scor de trecere,
+Score out of 100,Scor din 100,
+Max Attempts,Încercări maxime,
+Enter 0 to waive limit,Introduceți 0 până la limita de renunțare,
+Grading Basis,Bazele gradării,
+Latest Highest Score,Cel mai mare scor,
+Latest Attempt,Ultima încercare,
+Quiz Activity,Activitate de testare,
+Enrollment,înrolare,
+Pass,Trece,
+Quiz Question,Întrebare întrebare,
+Quiz Result,Rezultatul testului,
+Selected Option,Opțiunea selectată,
+Correct,Corect,
+Wrong,Gresit,
+Room Name,Nume Cameră,
+Room Number,Număr Cameră,
+Seating Capacity,Numărul de locuri,
+House Name,Numele casei,
+EDU-STU-.YYYY.-,EDU-STU-.YYYY.-,
+Student Mobile Number,Elev Număr mobil,
+Joining Date,Data Angajării,
+Blood Group,Grupă de sânge,
+A+,A+,
+A-,A-,
+B+,B +,
+B-,B-,
+O+,O +,
+O-,O-,
+AB+,AB+,
+AB-,AB-,
+Nationality,Naţionalitate,
+Home Address,Adresa de acasa,
+Guardian Details,Detalii tutore,
+Guardians,tutorii,
+Sibling Details,Detalii sibling,
+Siblings,siblings,
+Exit,Iesire,
+Date of Leaving,Data Părăsirii,
+Leaving Certificate Number,Părăsirea Număr certificat,
+Reason For Leaving,Motivul plecării,
+Student Admission,Admiterea studenților,
+Admission Start Date,Data de începere a Admiterii,
+Admission End Date,Data de încheiere Admiterii,
+Publish on website,Publica pe site-ul,
+Eligibility and Details,Eligibilitate și detalii,
+Student Admission Program,Programul de Admitere în Studenți,
+Minimum Age,Varsta minima,
+Maximum Age,Vârsta maximă,
+Application Fee,Taxă de aplicare,
+Naming Series (for Student Applicant),Seria de denumire (pentru Student Solicitant),
+LMS Only,Numai LMS,
+EDU-APP-.YYYY.-,EDU-APP-.YYYY.-,
+Application Status,Starea aplicației,
+Application Date,Data aplicării,
+Student Attendance Tool,Instrumentul de student Participarea,
+Group Based On,Grup pe baza,
+Students HTML,HTML studenții,
+Group Based on,Grup bazat pe,
+Student Group Name,Numele grupului studențesc,
+Max Strength,Putere max,
+Set 0 for no limit,0 pentru a seta nici o limită,
+Instructors,instructorii,
+Student Group Creation Tool,Instrumentul de creare a grupului de student,
+Leave blank if you make students groups per year,Lăsați necompletat dacă faceți grupuri de elevi pe an,
+Get Courses,Cursuri de a lua,
+Separate course based Group for every Batch,Separați un grup bazat pe cursuri pentru fiecare lot,
+Leave unchecked if you don't want to consider batch while making course based groups. ,Lăsați necontrolabil dacă nu doriți să luați în considerare lotul în timp ce faceți grupuri bazate pe curs.,
+Student Group Creation Tool Course,Curs de grup studențesc instrument de creare,
+Course Code,Codul cursului,
+Student Group Instructor,Student Grup Instructor,
+Student Group Student,Student Group Student,
+Group Roll Number,Numărul rolurilor de grup,
+Student Guardian,student la Guardian,
+Relation,Relație,
+Mother,Mamă,
+Father,tată,
+Student Language,Limba Student,
+Student Leave Application,Aplicație elev Concediul,
+Mark as Present,Marcați ca prezent,
+Student Log,Jurnal de student,
+Academic,Academic,
+Achievement,Realizare,
+Student Report Generation Tool,Instrumentul de generare a rapoartelor elevilor,
+Include All Assessment Group,Includeți tot grupul de evaluare,
+Show Marks,Afișați marcajele,
+Add letterhead,Adăugă Antet,
+Print Section,Imprimare secțiune,
+Total Parents Teacher Meeting,Întâlnire între profesorii de părinți,
+Attended by Parents,Participat de părinți,
+Assessment Terms,Termeni de evaluare,
+Student Sibling,elev Sibling,
+Studying in Same Institute,Studiind în același Institut,
+NO,NU,
+YES,Da,
+Student Siblings,Siblings Student,
+Topic Content,Conținut subiect,
+Amazon MWS Settings,Amazon MWS Settings,
+ERPNext Integrations,Integrări ERPNext,
+Enable Amazon,Activați Amazon,
+MWS Credentials,Certificatele MWS,
+Seller ID,ID-ul vânzătorului,
+AWS Access Key ID,Codul AWS Access Key,
+MWS Auth Token,MWS Auth Token,
+Market Place ID,ID-ul pieței,
+AE,AE,
+AU,AU,
+BR,BR,
+CA,CA,
+CN,CN,
+DE,DE,
+ES,ES,
+FR,FR,
+IN,ÎN,
+JP,JP,
+IT,ACEASTA,
+MX,MX,
+UK,Regatul Unit,
+US,S.U.A.,
+Customer Type,tip de client,
+Market Place Account Group,Grupul de cont de pe piață,
+After Date,După data,
+Amazon will synch data updated after this date,Amazon va sincroniza datele actualizate după această dată,
+Sync Taxes and Charges,Sincronizați taxele și taxele,
+Get financial breakup of Taxes and charges data by Amazon ,Obțineți despărțirea financiară a datelor fiscale și taxe de către Amazon,
+Sync Products,Produse de sincronizare,
+Always sync your products from Amazon MWS before synching the Orders details,Sincronizați întotdeauna produsele dvs. de la Amazon MWS înainte de a sincroniza detaliile comenzilor,
+Sync Orders,Sincronizați comenzile,
+Click this button to pull your Sales Order data from Amazon MWS.,Faceți clic pe acest buton pentru a vă trage datele de comandă de vânzări de la Amazon MWS.,
+Enable Scheduled Sync,Activați sincronizarea programată,
+Check this to enable a scheduled Daily synchronization routine via scheduler,Verificați acest lucru pentru a activa o rutină zilnică de sincronizare programată prin programator,
+Max Retry Limit,Max Retry Limit,
+Exotel Settings,Setări Exotel,
+Account SID,Cont SID,
+API Token,Token API,
+GoCardless Mandate,GoCardless Mandate,
+Mandate,Mandat,
+GoCardless Customer,Clientul GoCardless,
+GoCardless Settings,Setări GoCardless,
+Webhooks Secret,Webhooks Secret,
+Plaid Settings,Setări Plaid,
+Synchronize all accounts every hour,Sincronizați toate conturile în fiecare oră,
+Plaid Client ID,Cod client Plaid,
+Plaid Secret,Plaid Secret,
+Plaid Environment,Mediu plaid,
+sandbox,Sandbox,
+development,dezvoltare,
+production,producție,
+QuickBooks Migrator,QuickBooks Migrator,
+Application Settings,Setările aplicației,
+Token Endpoint,Token Endpoint,
+Scope,domeniu,
+Authorization Settings,Setările de autorizare,
+Authorization Endpoint,Autorizație,
+Authorization URL,Adresa de autorizare,
+Quickbooks Company ID,Coduri de identificare rapidă a companiei,
+Company Settings,Setări Company,
+Default Shipping Account,Contul de transport implicit,
+Default Warehouse,Depozit Implicit,
+Default Cost Center,Centru Cost Implicit,
+Undeposited Funds Account,Contul fondurilor nedeclarate,
+Shopify Log,Magazinul de jurnal,
+Request Data,Solicită Date,
+Shopify Settings,Rafinați setările,
+status html,starea html,
+Enable Shopify,Activați Shopify,
+App Type,Tipul aplicației,
+Last Sync Datetime,Ultima dată de sincronizare,
+Shop URL,Adresa URL magazin,
+eg: frappe.myshopify.com,de ex .: frappe.myshopify.com,
+Shared secret,Secret împărtășit,
+Webhooks Details,Detaliile Webhooks,
+Webhooks,Webhooks,
+Customer Settings,Setările clientului,
+Default Customer,Client Implicit,
+Customer Group will set to selected group while syncing customers from Shopify,Grupul de clienți va seta grupul selectat în timp ce va sincroniza clienții din Shopify,
+For Company,Pentru Companie,
+Cash Account will used for Sales Invoice creation,Contul de numerar va fi utilizat pentru crearea facturii de vânzări,
+Update Price from Shopify To ERPNext Price List,Actualizați prețul de la Shopify la lista de prețuri ERP următoare,
+Default Warehouse to to create Sales Order and Delivery Note,Warehouse implicit pentru a crea o comandă de vânzări și o notă de livrare,
+Sales Order Series,Seria de comandă de vânzări,
+Import Delivery Notes from Shopify on Shipment,Importă note de livrare de la Shopify la expediere,
+Delivery Note Series,Seria de note de livrare,
+Import Sales Invoice from Shopify if Payment is marked,Importă factura de vânzare din Shopify dacă este marcată plata,
+Sales Invoice Series,Seria de facturi de vânzări,
+Shopify Tax Account,Achiziționați contul fiscal,
+Shopify Tax/Shipping Title,Achiziționați titlul fiscal / transport,
+ERPNext Account,Contul ERPNext,
+Shopify Webhook Detail,Bucurați-vă de detaliile Webhook,
+Webhook ID,ID-ul Webhook,
+Tally Migration,Migrația de tip Tally,
+Master Data,Date Master,
+"Data exported from Tally that consists of the Chart of Accounts, Customers, Suppliers, Addresses, Items and UOMs","Date exportate de la Tally care constă din Planul de conturi, clienți, furnizori, adrese, articole și UOM-uri",
+Is Master Data Processed,Sunt prelucrate datele master,
+Is Master Data Imported,Sunt importate datele de master,
+Tally Creditors Account,Contul creditorilor Tally,
+Creditors Account set in Tally,Contul creditorilor stabilit în Tally,
+Tally Debtors Account,Contul debitorilor,
+Debtors Account set in Tally,Contul debitorilor stabilit în Tally,
+Tally Company,Tally Company,
+Company Name as per Imported Tally Data,Numele companiei conform datelor importate Tally,
+Default UOM,UOM implicit,
+UOM in case unspecified in imported data,UOM în cazul nespecificat în datele importate,
+ERPNext Company,Compania ERPNext,
+Your Company set in ERPNext,Compania dvs. a fost setată în ERPNext,
+Processed Files,Fișiere procesate,
+Parties,Petreceri,
+UOMs,UOMs,
+Vouchers,Bonuri,
+Round Off Account,Rotunji cont,
+Day Book Data,Date despre cartea de zi,
+Day Book Data exported from Tally that consists of all historic transactions,"Date din agenda de zi exportate din Tally, care constă în toate tranzacțiile istorice",
+Is Day Book Data Processed,Sunt prelucrate datele despre cartea de zi,
+Is Day Book Data Imported,Sunt importate datele despre cartea de zi,
+Woocommerce Settings,Setări Woocommerce,
+Enable Sync,Activați sincronizarea,
+Woocommerce Server URL,Adresa URL a serverului Woocommerce,
+Secret,Secret,
+API consumer key,Cheia pentru consumatori API,
+API consumer secret,Secretul consumatorului API,
+Tax Account,Contul fiscal,
+Freight and Forwarding Account,Contul de expediere și de expediere,
+Creation User,Utilizator creație,
+"The user that will be used to create Customers, Items and Sales Orders. This user should have the relevant permissions.","Utilizatorul care va fi utilizat pentru a crea clienți, articole și comenzi de vânzare. Acest utilizator ar trebui să aibă permisiunile relevante.",
+"This warehouse will be used to create Sales Orders. The fallback warehouse is ""Stores"".",Acest depozit va fi folosit pentru a crea comenzi de vânzare. Depozitul în retragere este „Magazine”.,
+"The fallback series is ""SO-WOO-"".",Seria Fallback este „SO-WOO-”.,
+This company will be used to create Sales Orders.,Această companie va fi folosită pentru a crea comenzi de vânzare.,
+Delivery After (Days),Livrare după (zile),
+This is the default offset (days) for the Delivery Date in Sales Orders. The fallback offset is 7 days from the order placement date.,Aceasta este compensarea implicită (zile) pentru data livrării în comenzile de vânzare. Decalarea compensării este de 7 zile de la data plasării comenzii.,
+"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".",Acesta este UOM-ul implicit utilizat pentru articole și comenzi de vânzări. UOM-ul în rezervă este „Nos”.,
+Endpoints,Endpoints,
+Endpoint,Punct final,
+Antibiotic Name,Numele antibioticului,
+Healthcare Administrator,Administrator de asistență medicală,
+Laboratory User,Utilizator de laborator,
+Is Inpatient,Este internat,
+Default Duration (In Minutes),Durata implicită (în minute),
+Body Part,Parte a corpului,
+Body Part Link,Legătura părții corpului,
+HLC-CPR-.YYYY.-,HLC-CPR-.YYYY.-,
+Procedure Template,Șablon de procedură,
+Procedure Prescription,Procedura de prescriere,
+Service Unit,Unitate de service,
+Consumables,Consumabile,
+Consume Stock,Consumați stocul,
+Invoice Consumables Separately,Consumabile facturate separat,
+Consumption Invoiced,Consum facturat,
+Consumable Total Amount,Suma totală consumabilă,
+Consumption Details,Detalii despre consum,
+Nursing User,Utilizator Nursing,
+Clinical Procedure Item,Articol de procedură clinică,
+Invoice Separately as Consumables,Factureaza distinct ca si consumabile,
+Transfer Qty,Cantitate transfer,
+Actual Qty (at source/target),Cant. efectivă (la sursă/destinaţie),
+Is Billable,Este facturabil,
+Allow Stock Consumption,Permiteți consumul de stoc,
+Sample UOM,Exemplu UOM,
+Collection Details,Detaliile colecției,
+Change In Item,Modificare element,
+Codification Table,Tabelul de codificare,
+Complaints,Reclamații,
+Dosage Strength,Dozabilitate,
+Strength,Putere,
+Drug Prescription,Droguri de prescripție,
+Drug Name / Description,Denumirea / descrierea medicamentului,
+Dosage,Dozare,
+Dosage by Time Interval,Dozaj după intervalul de timp,
+Interval,Interval,
+Interval UOM,Interval UOM,
+Hour,Oră,
+Update Schedule,Actualizați programul,
+Exercise,Exercițiu,
+Difficulty Level,Nivel de dificultate,
+Counts Target,Numără ținta,
+Counts Completed,Număruri finalizate,
+Assistance Level,Nivelul de asistență,
+Active Assist,Asistență activă,
+Exercise Name,Numele exercițiului,
+Body Parts,Parti ale corpului,
+Exercise Instructions,Instrucțiuni de exerciții,
+Exercise Video,Video de exerciții,
+Exercise Steps,Pași de exerciții,
+Steps,Pași,
+Steps Table,Tabelul Pașilor,
+Exercise Type Step,Tipul exercițiului Pas,
+Max number of visit,Numărul maxim de vizite,
+Visited yet,Vizitată încă,
+Reference Appointments,Programări de referință,
+Valid till,Valabil până la,
+Fee Validity Reference,Referința valabilității taxei,
+Basic Details,Detalii de bază,
+HLC-PRAC-.YYYY.-,HLC-PRAC-.YYYY.-,
+Mobile,Mobil,
+Phone (R),Telefon (R),
+Phone (Office),Telefon (Office),
+Employee and User Details,Detalii despre angajat și utilizator,
+Hospital,Spital,
+Appointments,Programari,
+Practitioner Schedules,Practitioner Schedules,
+Charges,Taxe,
+Out Patient Consulting Charge,Taxă de consultanță pentru pacienți,
+Default Currency,Monedă Implicită,
+Healthcare Schedule Time Slot,Programul de îngrijire a sănătății Time Slot,
+Parent Service Unit,Serviciul pentru părinți,
+Service Unit Type,Tip de unitate de service,
+Allow Appointments,Permiteți întâlnirilor,
+Allow Overlap,Permiteți suprapunerea,
+Inpatient Occupancy,Ocuparea locului de muncă,
+Occupancy Status,Starea ocupației,
+Vacant,Vacant,
+Occupied,Ocupat,
+Item Details,Detalii despre articol,
+UOM Conversion in Hours,Conversie UOM în ore,
+Rate / UOM,Rata / UOM,
+Change in Item,Modificați articolul,
+Out Patient Settings,Setări pentru pacient,
+Patient Name By,Nume pacient,
+Patient Name,Numele pacientului,
+Link Customer to Patient,Conectați clientul la pacient,
+"If checked, a customer will be created, mapped to Patient.\nPatient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.","Dacă este bifată, va fi creat un client, cartografiat pacientului. Facturile de pacienți vor fi create împotriva acestui Client. De asemenea, puteți selecta Clientul existent în timp ce creați pacientul.",
+Default Medical Code Standard,Standardul medical standard standard,
+Collect Fee for Patient Registration,Colectați taxa pentru înregistrarea pacientului,
+Checking this will create new Patients with a Disabled status by default and will only be enabled after invoicing the Registration Fee.,Verificând acest lucru se vor crea noi pacienți cu starea Dezactivat în mod implicit și vor fi activate numai după facturarea Taxei de înregistrare.,
+Registration Fee,Taxă de Înregistrare,
+Automate Appointment Invoicing,Automatizați facturarea programării,
+Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Gestionați trimiterea și anularea facturii de întâlnire în mod automat pentru întâlnirea cu pacienții,
+Enable Free Follow-ups,Activați urmăriri gratuite,
+Number of Patient Encounters in Valid Days,Numărul de întâlniri cu pacienți în zilele valabile,
+The number of free follow ups (Patient Encounters in valid days) allowed,Numărul de urmăriri gratuite (întâlniri cu pacienții în zile valide) permis,
+Valid Number of Days,Număr valid de zile,
+Time period (Valid number of days) for free consultations,Perioada de timp (număr valid de zile) pentru consultări gratuite,
+Default Healthcare Service Items,Articole prestabilite pentru serviciile medicale,
+"You can configure default Items for billing consultation charges, procedure consumption items and inpatient visits","Puteți configura articole implicite pentru facturarea taxelor de consultare, a articolelor de consum procedură și a vizitelor internate",
+Clinical Procedure Consumable Item,Procedura clinică Consumabile,
+Default Accounts,Conturi implicite,
+Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,Conturile de venit implicite care trebuie utilizate dacă nu sunt stabilite în practicienii din domeniul sănătății pentru a rezerva taxele de numire.,
+Default receivable accounts to be used to book Appointment charges.,Conturi de creanță implicite care urmează să fie utilizate pentru rezervarea cheltuielilor pentru programare.,
+Out Patient SMS Alerts,Alerte SMS ale pacientului,
+Patient Registration,Inregistrarea pacientului,
+Registration Message,Mesaj de înregistrare,
+Confirmation Message,Mesaj de confirmare,
+Avoid Confirmation,Evitați confirmarea,
+Do not confirm if appointment is created for the same day,Nu confirmați dacă se creează o întâlnire pentru aceeași zi,
+Appointment Reminder,Memento pentru numire,
+Reminder Message,Mesaj Memento,
+Remind Before,Memento Înainte,
+Laboratory Settings,Setări de laborator,
+Create Lab Test(s) on Sales Invoice Submission,Creați teste de laborator la trimiterea facturilor de vânzări,
+Checking this will create Lab Test(s) specified in the Sales Invoice on submission.,Verificând acest lucru se vor crea teste de laborator specificate în factura de vânzare la trimitere.,
+Create Sample Collection document for Lab Test,Creați un document de colectare a probelor pentru testul de laborator,
+Checking this will create a Sample Collection document  every time you create a Lab Test,"Verificând acest lucru, veți crea un document de colectare a probelor de fiecare dată când creați un test de laborator",
+Employee name and designation in print,Numele și denumirea angajatului în imprimat,
+Check this if you want the Name and Designation of the Employee associated with the User who submits the document to be printed in the Lab Test Report.,Bifați acest lucru dacă doriți ca numele și denumirea angajatului asociate cu utilizatorul care trimite documentul să fie tipărite în raportul de testare de laborator.,
+Do not print or email Lab Tests without Approval,Nu imprimați sau trimiteți prin e-mail testele de laborator fără aprobare,
+Checking this will restrict printing and emailing of Lab Test documents unless they have the status as Approved.,"Verificarea acestui lucru va restricționa imprimarea și trimiterea prin e-mail a documentelor de test de laborator, cu excepția cazului în care acestea au statutul de Aprobat.",
+Custom Signature in Print,Semnătură personalizată în imprimare,
+Laboratory SMS Alerts,Alerte SMS de laborator,
+Result Printed Message,Rezultat Mesaj tipărit,
+Result Emailed Message,Rezultat Mesaj prin e-mail,
+Check In,Verifica,
+Check Out,Verifică,
+HLC-INP-.YYYY.-,HLC-INP-.YYYY.-,
+A Positive,A Pozitive,
+A Negative,Un negativ,
+AB Positive,AB pozitiv,
+AB Negative,AB Negativ,
+B Positive,B pozitiv,
+B Negative,B Negativ,
+O Positive,O pozitiv,
+O Negative,O Negativ,
+Date of birth,Data Nașterii,
+Admission Scheduled,Admiterea programată,
+Discharge Scheduled,Descărcarea programată,
+Discharged,evacuate,
+Admission Schedule Date,Data calendarului de admitere,
+Admitted Datetime,Timpul admis,
+Expected Discharge,Descărcarea anticipată,
+Discharge Date,Data descărcării,
+Lab Prescription,Lab prescription,
+Lab Test Name,Numele testului de laborator,
+Test Created,Testul a fost creat,
+Submitted Date,Data transmisă,
+Approved Date,Data aprobarii,
+Sample ID,ID-ul probelor,
+Lab Technician,Tehnician de laborator,
+Report Preference,Raportați raportul,
+Test Name,Numele testului,
+Test Template,Șablon de testare,
+Test Group,Grupul de testare,
+Custom Result,Rezultate personalizate,
+LabTest Approver,LabTest Approver,
+Add Test,Adăugați test,
+Normal Range,Interval normal,
+Result Format,Formatul rezultatelor,
+Single,Celibatar,
+Compound,Compus,
+Descriptive,Descriptiv,
+Grouped,grupate,
+No Result,Nici un rezultat,
+This value is updated in the Default Sales Price List.,Această valoare este actualizată în lista prestabilită a prețurilor de vânzare.,
+Lab Routine,Laboratorul de rutină,
+Result Value,Valoare Rezultat,
+Require Result Value,Necesita valoarea rezultatului,
+Normal Test Template,Șablonul de test normal,
+Patient Demographics,Demografia pacientului,
+HLC-PAT-.YYYY.-,HLC-PAT-.YYYY.-,
+Middle Name (optional),Prenume (opțional),
+Inpatient Status,Starea staționarului,
+"If ""Link Customer to Patient"" is checked in Healthcare Settings and an existing Customer is not selected then, a Customer will be created for this Patient for recording transactions in Accounts module.","Dacă „Link Client to Pacient” este bifat în Setările asistenței medicale și un Client existent nu este selectat, atunci va fi creat un Client pentru acest Pacient pentru înregistrarea tranzacțiilor în modulul Conturi.",
+Personal and Social History,Istoria personală și socială,
+Marital Status,Stare civilă,
+Married,Căsătorit,
+Divorced,Divorțat/a,
+Widow,Văduvă,
+Patient Relation,Relația pacientului,
+"Allergies, Medical and Surgical History","Alergii, Istorie medicală și chirurgicală",
+Allergies,Alergii,
+Medication,Medicament,
+Medical History,Istoricul medical,
+Surgical History,Istorie chirurgicală,
+Risk Factors,Factori de Risc,
+Occupational Hazards and Environmental Factors,Riscuri Ocupaționale și Factori de Mediu,
+Other Risk Factors,Alți factori de risc,
+Patient Details,Detalii pacient,
+Additional information regarding the patient,Informații suplimentare privind pacientul,
+HLC-APP-.YYYY.-,HLC-APP-.YYYY.-,
+Patient Age,Vârsta pacientului,
+Get Prescribed Clinical Procedures,Obțineți proceduri clinice prescrise,
+Therapy,Terapie,
+Get Prescribed Therapies,Obțineți terapii prescrise,
+Appointment Datetime,Data programării,
+Duration (In Minutes),Durata (în minute),
+Reference Sales Invoice,Factură de vânzare de referință,
+More Info,Mai multe informatii,
+Referring Practitioner,Practicant referitor,
+Reminded,Reamintit,
+HLC-PA-.YYYY.-,HLC-PA-.YYYY.-,
+Assessment Template,Șablon de evaluare,
+Assessment Datetime,Evaluare Datetime,
+Assessment Description,Evaluare Descriere,
+Assessment Sheet,Fișa de evaluare,
+Total Score Obtained,Scorul total obținut,
+Scale Min,Scală Min,
+Scale Max,Scală Max,
+Patient Assessment Detail,Detaliu evaluare pacient,
+Assessment Parameter,Parametru de evaluare,
+Patient Assessment Parameter,Parametrul de evaluare a pacientului,
+Patient Assessment Sheet,Fișa de evaluare a pacientului,
+Patient Assessment Template,Șablon de evaluare a pacientului,
+Assessment Parameters,Parametrii de evaluare,
+Parameters,Parametrii,
+Assessment Scale,Scara de evaluare,
+Scale Minimum,Scala minimă,
+Scale Maximum,Scală maximă,
+HLC-ENC-.YYYY.-,HLC-ENC-.YYYY.-,
+Encounter Date,Data întâlnirii,
+Encounter Time,Întâlniți timpul,
+Encounter Impression,Întâlniți impresiile,
+Symptoms,Simptome,
+In print,În imprimare,
+Medical Coding,Codificarea medicală,
+Procedures,Proceduri,
+Therapies,Terapii,
+Review Details,Detalii de examinare,
+Patient Encounter Diagnosis,Diagnosticul întâlnirii pacientului,
+Patient Encounter Symptom,Simptomul întâlnirii pacientului,
+HLC-PMR-.YYYY.-,HLC-PMR-.YYYY.-,
+Attach Medical Record,Atașați fișa medicală,
+Reference DocType,DocType de referință,
+Spouse,soț,
+Family,Familie,
+Schedule Details,Detalii program,
+Schedule Name,Numele programului,
+Time Slots,Intervale de timp,
+Practitioner Service Unit Schedule,Unitatea Serviciului de Practician,
+Procedure Name,Numele procedurii,
+Appointment Booked,Numirea rezervată,
+Procedure Created,Procedura creată,
+HLC-SC-.YYYY.-,HLC-SC-.YYYY.-,
+Collected By,Colectată de,
+Particulars,Particularități,
+Result Component,Componenta Rezultat,
+HLC-THP-.YYYY.-,HLC-THP-.YYYY.-,
+Therapy Plan Details,Detalii despre planul de terapie,
+Total Sessions,Total sesiuni,
+Total Sessions Completed,Total sesiuni finalizate,
+Therapy Plan Detail,Detaliu plan de terapie,
+No of Sessions,Nr de sesiuni,
+Sessions Completed,Sesiuni finalizate,
+Tele,Tele,
+Exercises,Exerciții,
+Therapy For,Terapie pt,
+Add Exercises,Adăugați exerciții,
+Body Temperature,Temperatura corpului,
+Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Prezența febrei (temperatură&gt; 38,5 ° C sau temperatură susținută&gt; 38 ° C / 100,4 ° F)",
+Heart Rate / Pulse,Ritm cardiac / puls,
+Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Rata pulsului adulților este între 50 și 80 de bătăi pe minut.,
+Respiratory rate,Rata respiratorie,
+Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Intervalul normal de referință pentru un adult este de 16-20 respirații / minut (RCP 2012),
+Tongue,Limbă,
+Coated,Acoperit,
+Very Coated,Foarte acoperit,
+Normal,Normal,
+Furry,Cu blană,
+Cuts,Bucăți,
+Abdomen,Abdomen,
+Bloated,Umflat,
+Fluid,Fluid,
+Constipated,Constipat,
+Reflexes,reflexe,
+Hyper,Hyper,
+Very Hyper,Foarte Hyper,
+One Sided,O singură față,
+Blood Pressure (systolic),Tensiunea arterială (sistolică),
+Blood Pressure (diastolic),Tensiunea arterială (diastolică),
+Blood Pressure,Tensiune arteriala,
+"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Tensiunea arterială normală de repaus la un adult este de aproximativ 120 mmHg sistolică și 80 mmHg diastolică, abreviată &quot;120/80 mmHg&quot;",
+Nutrition Values,Valorile nutriției,
+Height (In Meter),Înălțime (în metri),
+Weight (In Kilogram),Greutate (în kilograme),
+BMI,IMC,
+Hotel Room,Cameră de hotel,
+Hotel Room Type,Tip camera de hotel,
+Capacity,Capacitate,
+Extra Bed Capacity,Capacitatea patului suplimentar,
+Hotel Manager,Hotel Manager,
+Hotel Room Amenity,Hotel Amenity Room,
+Billable,Facturabil,
+Hotel Room Package,Pachetul de camere hotel,
+Amenities,dotări,
+Hotel Room Pricing,Pretul camerei hotelului,
+Hotel Room Pricing Item,Hotel Pricing Room Item,
+Hotel Room Pricing Package,Pachetul pentru tarifarea camerei hotelului,
+Hotel Room Reservation,Rezervarea camerelor hotelului,
+Guest Name,Numele oaspetelui,
+Late Checkin,Încearcă târziu,
+Booked,rezervat,
+Hotel Reservation User,Utilizator rezervare hotel,
+Hotel Room Reservation Item,Rezervare cameră cameră,
+Hotel Settings,Setările hotelului,
+Default Taxes and Charges,Impozite și taxe prestabilite,
+Default Invoice Naming Series,Seria implicită de numire a facturilor,
+Additional Salary,Salariu suplimentar,
+HR,HR,
+HR-ADS-.YY.-.MM.-,HR-ADS-.YY .-. MM.-,
+Salary Component,Componenta de salarizare,
+Overwrite Salary Structure Amount,Suprascrieți suma structurii salariilor,
+Deduct Full Tax on Selected Payroll Date,Reduceți impozitul complet pe data de salarizare selectată,
+Payroll Date,Data salarizării,
+Date on which this component is applied,Data la care se aplică această componentă,
+Salary Slip,Salariul Slip,
+Salary Component Type,Tipul componentei salariale,
+HR User,Utilizator HR,
+Appointment Letter,Scrisoare de programare,
+Job Applicant,Solicitant loc de muncă,
+Applicant Name,Nume solicitant,
+Appointment Date,Data de intalnire,
+Appointment Letter Template,Model de scrisoare de numire,
+Body,Corp,
+Closing Notes,Note de închidere,
+Appointment Letter content,Numire scrisoare conținut,
+Appraisal,Expertiză,
+HR-APR-.YY.-.MM.,HR-APR-.YY.-.MM.,
+Appraisal Template,Model expertiză,
+For Employee Name,Pentru Numele Angajatului,
+Goals,Obiective,
+Total Score (Out of 5),Scor total (din 5),
+"Any other remarks, noteworthy effort that should go in the records.","Orice alte observații, efort remarcabil care ar trebui înregistrate.",
+Appraisal Goal,Obiectiv expertiză,
+Key Responsibility Area,Domeni de Responsabilitate Cheie,
+Weightage (%),Weightage (%),
+Score (0-5),Scor (0-5),
+Score Earned,Scor Earned,
+Appraisal Template Title,Titlu model expertivă,
+Appraisal Template Goal,Obiectiv model expertivă,
+KRA,KRA,
+Key Performance Area,Domeniu de Performanță Cheie,
+HR-ATT-.YYYY.-,HR-ATT-.YYYY.-,
+On Leave,La plecare,
+Work From Home,Lucru de acasă,
+Leave Application,Aplicatie pentru Concediu,
+Attendance Date,Dată prezenţă,
+Attendance Request,Cererea de participare,
+Late Entry,Intrare târzie,
+Early Exit,Iesire timpurie,
+Half Day Date,Jumatate de zi Data,
+On Duty,La datorie,
+Explanation,Explicaţie,
+Compensatory Leave Request,Solicitare de plecare compensatorie,
+Leave Allocation,Alocare Concediu,
+Worked On Holiday,Lucrat în vacanță,
+Work From Date,Lucrul de la data,
+Work End Date,Data terminării lucrării,
+Email Sent To,Email trimis catre,
+Select Users,Selectați Utilizatori,
+Send Emails At,Trimite email-uri La,
+Reminder,Memento,
+Daily Work Summary Group User,Utilizatorul grupului zilnic de lucru sumar,
+email,e-mail,
+Parent Department,Departamentul părinților,
+Leave Block List,Lista Concedii Blocate,
+Days for which Holidays are blocked for this department.,Zile pentru care Sărbătorile sunt blocate pentru acest departament.,
+Leave Approver,Aprobator Concediu,
+Expense Approver,Aprobator Cheltuieli,
+Department Approver,Departamentul Aprobare,
+Approver,Aprobator,
+Required Skills,Aptitudini necesare,
+Skills,Aptitudini,
+Designation Skill,Indemanare de desemnare,
+Skill,Calificare,
+Driver,Conducător auto,
+HR-DRI-.YYYY.-,HR-DRI-.YYYY.-,
+Suspended,Suspendat,
+Transporter,Transporter,
+Applicable for external driver,Aplicabil pentru driverul extern,
+Cellphone Number,Număr de Telefon Mobil,
+License Details,Detalii privind licența,
+License Number,Numărul de licență,
+Issuing Date,Data emiterii,
+Driving License Categories,Categorii de licență de conducere,
+Driving License Category,Categoria permiselor de conducere,
+Fleet Manager,Manager de flotă,
+Driver licence class,Clasa permisului de conducere,
+HR-EMP-,HR-vorba sunt,
+Employment Type,Tip angajare,
+Emergency Contact,Contact de Urgență,
+Emergency Contact Name,Nume de contact de urgență,
+Emergency Phone,Telefon de Urgență,
+ERPNext User,Utilizator ERPNext,
+"System User (login) ID. If set, it will become default for all HR forms.","ID Utilizator Sistem (conectare). Dacă este setat, va deveni implicit pentru toate formularele de resurse umane.",
+Create User Permission,Creați permisiunea utilizatorului,
+This will restrict user access to other employee records,Acest lucru va restricționa accesul utilizatorilor la alte înregistrări ale angajaților,
+Joining Details,Detalii Angajare,
+Offer Date,Oferta Date,
+Confirmation Date,Data de Confirmare,
+Contract End Date,Data de Incheiere Contract,
+Notice (days),Preaviz (zile),
+Date Of Retirement,Data Pensionării,
+Department and Grade,Departamentul și Gradul,
+Reports to,Rapoartează către,
+Attendance and Leave Details,Detalii de participare și concediu,
+Leave Policy,Lasati politica,
+Attendance Device ID (Biometric/RF tag ID),Prezentarea dispozitivului de identificare (biometric / RF tag tag),
+Applicable Holiday List,Listă de concedii aplicabile,
+Default Shift,Schimbare implicită,
+Salary Details,Detalii salariu,
+Salary Mode,Mod de salariu,
+Bank A/C No.,Bancă A/C nr.,
+Health Insurance,Asigurare de sanatate,
+Health Insurance Provider,Asigurari de sanatate,
+Health Insurance No,Asigurări de sănătate nr,
+Prefered Email,E-mail Preferam,
+Personal Email,Personal de e-mail,
+Permanent Address Is,Adresa permanentă este,
+Rented,Închiriate,
+Owned,Deținut,
+Permanent Address,Permanent Adresa,
+Prefered Contact Email,Contact Email Preferam,
+Company Email,E-mail Companie,
+Provide Email Address registered in company,Furnizarea Adresa de email inregistrata in companie,
+Current Address Is,Adresa Actuală Este,
+Current Address,Adresa actuală,
+Personal Bio,Personal Bio,
+Bio / Cover Letter,Bio / Cover Letter,
+Short biography for website and other publications.,Scurta biografie pentru site-ul web și alte publicații.,
+Passport Number,Numărul de pașaport,
+Date of Issue,Data Problemei,
+Place of Issue,Locul eliberării,
+Widowed,Văduvit,
+Family Background,Context familial,
+"Here you can maintain family details like name and occupation of parent, spouse and children","Aici puteți stoca detalii despre familie, cum ar fi numele și ocupația parintelui, sotului/sotiei și copiilor",
+Health Details,Detalii Sănătate,
+"Here you can maintain height, weight, allergies, medical concerns etc","Aici puteți stoca informatii despre inaltime, greutate, alergii, probleme medicale etc",
+Educational Qualification,Detalii Calificare de Învățământ,
+Previous Work Experience,Anterior Work Experience,
+External Work History,Istoricul lucrului externă,
+History In Company,Istoric In Companie,
+Internal Work History,Istoria interne de lucru,
+Resignation Letter Date,Dată Scrisoare de Demisie,
+Relieving Date,Alinarea Data,
+Reason for Leaving,Motiv pentru plecare,
+Leave Encashed?,Concediu Incasat ?,
+Encashment Date,Data plata in Numerar,
+New Workplace,Nou loc de muncă,
+HR-EAD-.YYYY.-,HR-EAD-.YYYY.-,
+Returned Amount,Suma restituită,
+Claimed,Revendicat,
+Advance Account,Advance Account,
+Employee Attendance Tool,Instrumentul Participarea angajat,
+Unmarked Attendance,Participarea nemarcat,
+Employees HTML,Angajații HTML,
+Marked Attendance,Participarea marcat,
+Marked Attendance HTML,Participarea marcat HTML,
+Employee Benefit Application,Aplicația pentru beneficiile angajaților,
+Max Benefits (Yearly),Beneficii maxime (anual),
+Remaining Benefits (Yearly),Alte beneficii (anuale),
+Payroll Period,Perioada de salarizare,
+Benefits Applied,Beneficii aplicate,
+Dispensed Amount (Pro-rated),Sumă distribuită (Pro-evaluată),
+Employee Benefit Application Detail,Detaliile aplicației pentru beneficiile angajaților,
+Earning Component,Componenta câștigurilor,
+Pay Against Benefit Claim,Plătiți împotriva revendicării beneficiilor,
+Max Benefit Amount,Suma maximă a beneficiilor,
+Employee Benefit Claim,Revendicarea beneficiilor pentru angajați,
+Claim Date,Data revendicării,
+Benefit Type and Amount,Tip de prestație și sumă,
+Claim Benefit For,Revendicați beneficiul pentru,
+Max Amount Eligible,Sumă maximă eligibilă,
+Expense Proof,Cheltuieli de probă,
+Employee Boarding Activity,Activitatea de îmbarcare a angajaților,
+Activity Name,Nume Activitate,
+Task Weight,sarcina Greutate,
+Required for Employee Creation,Necesar pentru crearea angajaților,
+Applicable in the case of Employee Onboarding,Aplicabil în cazul angajării angajaților,
+Employee Checkin,Verificarea angajatilor,
+Log Type,Tip jurnal,
+OUT,OUT,
+Location / Device ID,Locație / ID dispozitiv,
+Skip Auto Attendance,Treci la prezența automată,
+Shift Start,Start Shift,
+Shift End,Shift End,
+Shift Actual Start,Shift Start inițial,
+Shift Actual End,Schimbare finală efectivă,
+Employee Education,Educație Angajat,
+School/University,Școlar / universitar,
+Graduate,Absolvent,
+Post Graduate,Postuniversitar,
+Under Graduate,Sub Absolvent,
+Year of Passing,Ani de la promovarea,
+Class / Percentage,Clasă / Procent,
+Major/Optional Subjects,Subiecte Majore / Opționale,
+Employee External Work History,Istoric Extern Locuri de Munca Angajat,
+Total Experience,Experiența totală,
+Default Leave Policy,Implicit Politica de plecare,
+Default Salary Structure,Structura salarială implicită,
+Employee Group Table,Tabelul grupului de angajați,
+ERPNext User ID,ID utilizator ERPNext,
+Employee Health Insurance,Angajarea Asigurărilor de Sănătate,
+Health Insurance Name,Nume de Asigurări de Sănătate,
+Employee Incentive,Angajament pentru angajați,
+Incentive Amount,Sumă stimulativă,
+Employee Internal Work History,Istoric Intern Locuri de Munca Angajat,
+Employee Onboarding,Angajarea la bord,
+Notify users by email,Notifica utilizatorii prin e-mail,
+Employee Onboarding Template,Formularul de angajare a angajatului,
+Activities,Activități,
+Employee Onboarding Activity,Activitatea de angajare a angajaților,
+Employee Other Income,Alte venituri ale angajaților,
+Employee Promotion,Promovarea angajaților,
+Promotion Date,Data promoției,
+Employee Promotion Details,Detaliile de promovare a angajaților,
+Employee Promotion Detail,Detaliile de promovare a angajaților,
+Employee Property History,Istoricul proprietății angajatului,
+Employee Separation,Separarea angajaților,
+Employee Separation Template,Șablon de separare a angajaților,
+Exit Interview Summary,Exit Interviu Rezumat,
+Employee Skill,Indemanarea angajatilor,
+Proficiency,Experiență,
+Evaluation Date,Data evaluării,
+Employee Skill Map,Harta de îndemânare a angajaților,
+Employee Skills,Abilități ale angajaților,
+Trainings,instruiri,
+Employee Tax Exemption Category,Angajament categoria de scutire fiscală,
+Max Exemption Amount,Suma maximă de scutire,
+Employee Tax Exemption Declaration,Declarația de scutire fiscală a angajaților,
+Declarations,Declaraţii,
+Total Declared Amount,Suma totală declarată,
+Total Exemption Amount,Valoarea totală a scutirii,
+Employee Tax Exemption Declaration Category,Declarația de scutire fiscală a angajaților,
+Exemption Sub Category,Scutirea subcategoria,
+Exemption Category,Categoria de scutire,
+Maximum Exempted Amount,Suma maximă scutită,
+Declared Amount,Suma declarată,
+Employee Tax Exemption Proof Submission,Sustine gratuitatea acestui serviciu si acceseaza,
+Submission Date,Data depunerii,
+Tax Exemption Proofs,Dovezi privind scutirea de taxe,
+Total Actual Amount,Suma totală reală,
+Employee Tax Exemption Proof Submission Detail,Angajamentul de scutire fiscală Detaliu de prezentare a probelor,
+Maximum Exemption Amount,Suma maximă de scutire,
+Type of Proof,Tip de probă,
+Actual Amount,Suma reală,
+Employee Tax Exemption Sub Category,Scutirea de impozit pe categorii de angajați,
+Tax Exemption Category,Categoria de scutire de taxe,
+Employee Training,Instruirea angajaților,
+Training Date,Data formării,
+Employee Transfer,Transfer de angajați,
+Transfer Date,Data transferului,
+Employee Transfer Details,Detaliile transferului angajatului,
+Employee Transfer Detail,Detalii despre transferul angajatului,
+Re-allocate Leaves,Re-alocarea frunzelor,
+Create New Employee Id,Creați un nou număr de angajați,
+New Employee ID,Codul angajatului nou,
+Employee Transfer Property,Angajamentul transferului de proprietate,
+HR-EXP-.YYYY.-,HR-EXP-.YYYY.-,
+Expense Taxes and Charges,Cheltuiește impozite și taxe,
+Total Sanctioned Amount,Suma totală sancționat,
+Total Advance Amount,Suma totală a avansului,
+Total Claimed Amount,Total suma pretinsă,
+Total Amount Reimbursed,Total suma rambursată,
+Vehicle Log,vehicul Log,
+Employees Email Id,Id Email Angajat,
+More Details,Mai multe detalii,
+Expense Claim Account,Cont Solicitare Cheltuială,
+Expense Claim Advance,Avans Solicitare Cheltuială,
+Unclaimed amount,Sumă nerevendicată,
+Expense Claim Detail,Detaliu Solicitare Cheltuială,
+Expense Date,Data cheltuieli,
+Expense Claim Type,Tip Solicitare Cheltuială,
+Holiday List Name,Denumire Lista de Vacanță,
+Total Holidays,Total sărbători,
+Add Weekly Holidays,Adăugă Sărbători Săptămânale,
+Weekly Off,Săptămânal Off,
+Add to Holidays,Adăugă la Sărbători,
+Holidays,Concedii,
+Clear Table,Sterge Masa,
+HR Settings,Setări Resurse Umane,
+Employee Settings,Setări Angajat,
+Retirement Age,Vârsta de pensionare,
+Enter retirement age in years,Introdu o vârsta de pensionare în anii,
+Stop Birthday Reminders,De oprire de naștere Memento,
+Expense Approver Mandatory In Expense Claim,Aprobator Cheltuieli Obligatoriu în Solicitare Cheltuială,
+Payroll Settings,Setări de salarizare,
+Leave,Părăsi,
+Max working hours against Timesheet,Max ore de lucru împotriva Pontaj,
+Include holidays in Total no. of Working Days,Includ vacanțe în total nr. de zile lucrătoare,
+"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","In cazul in care se bifeaza, nr. total de zile lucratoare va include si sarbatorile, iar acest lucru va reduce valoarea Salariul pe Zi",
+"If checked, hides and disables Rounded Total field in Salary Slips","Dacă este bifat, ascunde și dezactivează câmpul total rotunjit din Slips-uri de salariu",
+The fraction of daily wages to be paid for half-day attendance,Fracțiunea salariilor zilnice care trebuie plătită pentru participarea la jumătate de zi,
+Email Salary Slip to Employee,E-mail Salariu Slip angajatului,
+Emails salary slip to employee based on preferred email selected in Employee,alunecare email-uri salariul angajatului în funcție de e-mail preferat selectat în Angajat,
+Encrypt Salary Slips in Emails,Criptați diapozitive de salariu în e-mailuri,
+"The salary slip emailed to the employee will be password protected, the password will be generated based on the password policy.","Fișa de salariu trimisă către angajat va fi protejată prin parolă, parola va fi generată pe baza politicii de parolă.",
+Password Policy,Politica de parolă,
+<b>Example:</b> SAL-{first_name}-{date_of_birth.year} <br>This will generate a password like SAL-Jane-1972,<b>Exemplu:</b> SAL- {first_name} - {date_of_birth.year} <br> Aceasta va genera o parolă precum SAL-Jane-1972,
+Leave Settings,Lăsați Setările,
+Leave Approval Notification Template,Lăsați șablonul de notificare de aprobare,
+Leave Status Notification Template,Părăsiți șablonul de notificare a statutului,
+Role Allowed to Create Backdated Leave Application,Rolul permis pentru a crea o cerere de concediu retardat,
+Leave Approver Mandatory In Leave Application,Concedierea obligatorie la cerere,
+Show Leaves Of All Department Members In Calendar,Afișați frunzele tuturor membrilor departamentului în calendar,
+Auto Leave Encashment,Auto Encashment,
+Hiring Settings,Setări de angajare,
+Check Vacancies On Job Offer Creation,Verificați posturile vacante pentru crearea ofertei de locuri de muncă,
+Identification Document Type,Tipul documentului de identificare,
+Effective from,Efectiv de la,
+Allow Tax Exemption,Permiteți scutirea de taxe,
+"If enabled, Tax Exemption Declaration will be considered for income tax calculation.","Dacă este activată, Declarația de scutire de impozit va fi luată în considerare pentru calcularea impozitului pe venit.",
+Standard Tax Exemption Amount,Suma standard de scutire de impozit,
+Taxable Salary Slabs,Taxe salariale,
+Taxes and Charges on Income Tax,Impozite și taxe pe impozitul pe venit,
+Other Taxes and Charges,Alte impozite și taxe,
+Income Tax Slab Other Charges,Impozitul pe venit Slab Alte taxe,
+Min Taxable Income,Venit minim impozabil,
+Max Taxable Income,Venitul maxim impozabil,
+Applicant for a Job,Solicitant pentru un loc de muncă,
+Accepted,Acceptat,
+Job Opening,Loc de munca disponibil,
+Cover Letter,Scrisoare de intenție,
+Resume Attachment,CV-Atașamentul,
+Job Applicant Source,Sursă Solicitant Loc de Muncă,
+Applicant Email Address,Adresa de e-mail a solicitantului,
+Awaiting Response,Se aşteaptă răspuns,
+Job Offer Terms,Condiții Ofertă de Muncă,
+Select Terms and Conditions,Selectați Termeni și condiții,
+Printing Details,Imprimare Detalii,
+Job Offer Term,Termen Ofertă de Muncă,
+Offer Term,Termen oferta,
+Value / Description,Valoare / Descriere,
+Description of a Job Opening,Descrierea unei slujbe,
+Job Title,Denumire Post,
+Staffing Plan,Planul de personal,
+Planned number of Positions,Număr planificat de poziții,
+"Job profile, qualifications required etc.","Profilul postului, calificări necesare, etc",
+HR-LAL-.YYYY.-,HR-LAL-.YYYY.-,
+Allocation,Alocare,
+New Leaves Allocated,Cereri noi de concediu alocate,
+Add unused leaves from previous allocations,Adăugați zile de concediu neutilizate de la alocări anterioare,
+Unused leaves,Frunze neutilizate,
+Total Leaves Allocated,Totalul Frunze alocate,
+Total Leaves Encashed,Frunze totale încorporate,
+Leave Period,Lăsați perioada,
+Carry Forwarded Leaves,Trasmite Concedii Inaintate,
+Apply / Approve Leaves,Aplicați / aprobaţi concedii,
+HR-LAP-.YYYY.-,HR-LAP-.YYYY.-,
+Leave Balance Before Application,Balanta Concediu Inainte de Aplicare,
+Total Leave Days,Total de zile de concediu,
+Leave Approver Name,Lăsați Nume aprobator,
+Follow via Email,Urmați prin e-mail,
+Block Holidays on important days.,Blocaţi zile de sărbătoare în zilele importante.,
+Leave Block List Name,Denumire Lista Concedii Blocate,
+Applies to Company,Se aplică companiei,
+"If not checked, the list will have to be added to each Department where it has to be applied.","In cazul in care este debifat, lista va trebui să fie adăugata fiecarui Departament unde trebuie sa fie aplicată.",
+Block Days,Zile de blocare,
+Stop users from making Leave Applications on following days.,Opri utilizatorii de la a face aplicații concediu pentru următoarele zile.,
+Leave Block List Dates,Date Lista Concedii Blocate,
+Allow Users,Permiteți utilizatori,
+Allow the following users to approve Leave Applications for block days.,Permiteţi următorilor utilizatori să aprobe cereri de concediu pentru zile blocate.,
+Leave Block List Allowed,Lista Concedii Blocate Permise,
+Leave Block List Allow,Permite Lista Concedii Blocate,
+Allow User,Permiteţi utilizator,
+Leave Block List Date,Data Lista Concedii Blocate,
+Block Date,Dată blocare,
+Leave Control Panel,Panou de Control Concediu,
+Select Employees,Selectați angajati,
+Employment Type (optional),Tip de angajare (opțional),
+Branch (optional),Sucursală (opțional),
+Department (optional),Departamentul (opțional),
+Designation (optional),Desemnare (opțional),
+Employee Grade (optional),Gradul angajatului (opțional),
+Employee (optional),Angajat (opțional),
+Allocate Leaves,Alocați frunzele,
+Carry Forward,Transmite Inainte,
+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,
+New Leaves Allocated (In Days),Cereri noi de concediu alocate (în zile),
+Allocate,Alocaţi,
+Leave Balance,Lasă balanța,
+Encashable days,Zile încorporate,
+Encashment Amount,Suma de încasare,
+Leave Ledger Entry,Lăsați intrarea în evidență,
+Transaction Name,Numele tranzacției,
+Is Carry Forward,Este Carry Forward,
+Is Expired,Este expirat,
+Is Leave Without Pay,Este concediu fără plată,
+Holiday List for Optional Leave,Lista de vacanță pentru concediul opțional,
+Leave Allocations,Lăsați alocările,
+Leave Policy Details,Lăsați detaliile politicii,
+Leave Policy Detail,Lăsați detaliile politicii,
+Annual Allocation,Alocarea anuală,
+Leave Type Name,Denumire Tip Concediu,
+Max Leaves Allowed,Frunzele maxime sunt permise,
+Applicable After (Working Days),Aplicabil după (zile lucrătoare),
+Maximum Continuous Days Applicable,Zilele maxime continue sunt aplicabile,
+Is Optional Leave,Este concediu opțională,
+Allow Negative Balance,Permiteţi sold negativ,
+Include holidays within leaves as leaves,Includ zilele de sărbătoare în frunze ca frunze,
+Is Compensatory,Este compensatorie,
+Maximum Carry Forwarded Leaves,Frunze transmise maxim transportat,
+Expire Carry Forwarded Leaves (Days),Expirați transportați frunzele transmise (zile),
+Calculated in days,Calculat în zile,
+Encashment,Încasare,
+Allow Encashment,Permiteți încorporarea,
+Encashment Threshold Days,Zilele pragului de încasare,
+Earned Leave,Salariu câștigat,
+Is Earned Leave,Este lăsat câștigat,
+Earned Leave Frequency,Frecvența de plecare câștigată,
+Rounding,Rotunjire,
+Payroll Employee Detail,Detaliile salariaților salariați,
+Payroll Frequency,Frecventa de salarizare,
+Fortnightly,bilunară,
+Bimonthly,Bilunar,
+Employees,Numar de angajati,
+Number Of Employees,Numar de angajati,
+Employee Details,Detalii angajaților,
+Validate Attendance,Validați participarea,
+Salary Slip Based on Timesheet,Bazat pe salariu Slip Pontaj,
+Select Payroll Period,Perioada de selectare Salarizare,
+Deduct Tax For Unclaimed Employee Benefits,Deducerea Impozitelor Pentru Beneficiile Nerecuperate ale Angajaților,
+Deduct Tax For Unsubmitted Tax Exemption Proof,Deducerea impozitului pentru dovada scutirii fiscale neimpozitate,
+Select Payment Account to make Bank Entry,Selectați Cont de plăți pentru a face Banca de intrare,
+Salary Slips Created,Slipsuri salariale create,
+Salary Slips Submitted,Salariile trimise,
+Payroll Periods,Perioade de salarizare,
+Payroll Period Date,Data perioadei de salarizare,
+Purpose of Travel,Scopul călătoriei,
+Retention Bonus,Bonus de Retenție,
+Bonus Payment Date,Data de plată Bonus,
+Bonus Amount,Bonus Suma,
+Abbr,Presc,
+Depends on Payment Days,Depinde de Zilele de plată,
+Is Tax Applicable,Taxa este aplicabilă,
+Variable Based On Taxable Salary,Variabilă pe salariu impozabil,
+Exempted from Income Tax,Scutit de impozitul pe venit,
+Round to the Nearest Integer,Rotund la cel mai apropiat număr întreg,
+Statistical Component,Componenta statistică,
+"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Dacă este selectată, valoarea specificată sau calculată în această componentă nu va contribui la câștigurile sau deducerile. Cu toate acestea, valoarea sa poate fi menționată de alte componente care pot fi adăugate sau deduse.",
+Do Not Include in Total,Nu includeți în total,
+Flexible Benefits,Beneficii flexibile,
+Is Flexible Benefit,Este benefică flexibilă,
+Max Benefit Amount (Yearly),Sumă maximă pentru beneficiu (anual),
+Only Tax Impact (Cannot Claim But Part of Taxable Income),"Numai impactul fiscal (nu poate fi revendicat, ci parte din venitul impozabil)",
+Create Separate Payment Entry Against Benefit Claim,Creați o intrare separată de plată împotriva revendicării beneficiilor,
+Condition and Formula,Condiție și formulă,
+Amount based on formula,Suma bazată pe formula generală,
+Formula,Formulă,
+Salary Detail,Detalii salariu,
+Component,component,
+Do not include in total,Nu includeți în total,
+Default Amount,Sumă Implicită,
+Additional Amount,Suma suplimentară,
+Tax on flexible benefit,Impozitul pe beneficii flexibile,
+Tax on additional salary,Impozit pe salariu suplimentar,
+Salary Structure,Structura salariu,
+Working Days,Zile lucratoare,
+Salary Slip Timesheet,Salariu alunecare Pontaj,
+Total Working Hours,Numărul total de ore de lucru,
+Hour Rate,Rata Oră,
+Bank Account No.,Cont bancar nr.,
+Earning & Deduction,Câștig Salarial si Deducere,
+Earnings,Câștiguri,
+Deductions,Deduceri,
+Loan repayment,Rambursare a creditului,
+Employee Loan,angajat de împrumut,
+Total Principal Amount,Sumă totală principală,
+Total Interest Amount,Suma totală a dobânzii,
+Total Loan Repayment,Rambursarea totală a creditului,
+net pay info,info net pay,
+Gross Pay - Total Deduction - Loan Repayment,Plata brută - Deducerea totală - rambursare a creditului,
+Total in words,Total în cuvinte,
+Net Pay (in words) will be visible once you save the Salary Slip.,Pay net (în cuvinte) vor fi vizibile după ce salvați fluturasul de salariu.,
+Salary Component for timesheet based payroll.,Componenta de salarizare pentru salarizare bazate pe timesheet.,
+Leave Encashment Amount Per Day,Părăsiți Suma de Invenție pe Zi,
+Max Benefits (Amount),Beneficii maxime (suma),
+Salary breakup based on Earning and Deduction.,Salariul despartire bazat privind câștigul salarial și deducere.,
+Total Earning,Câștigul salarial total de,
+Salary Structure Assignment,Structura salarială,
+Shift Assignment,Schimbare asignare,
+Shift Type,Tip Shift,
+Shift Request,Cerere de schimbare,
+Enable Auto Attendance,Activați prezența automată,
+Mark attendance based on 'Employee Checkin' for Employees assigned to this shift.,Marcați prezența pe baza „Verificării angajaților” pentru angajații repartizați în această schimbă.,
+Auto Attendance Settings,Setări de prezență automată,
+Determine Check-in and Check-out,Determinați check-in și check-out,
+Alternating entries as IN and OUT during the same shift,Alternarea intrărilor ca IN și OUT în timpul aceleiași deplasări,
+Strictly based on Log Type in Employee Checkin,Strict bazat pe tipul de jurnal în verificarea angajaților,
+Working Hours Calculation Based On,Calculul orelor de lucru bazat pe,
+First Check-in and Last Check-out,Primul check-in și ultimul check-out,
+Every Valid Check-in and Check-out,Fiecare check-in și check-out valabil,
+Begin check-in before shift start time (in minutes),Începeți check-in-ul înainte de ora de începere a schimbului (în minute),
+The time before the shift start time during which Employee Check-in is considered for attendance.,Timpul înainte de ora de începere a schimbului în timpul căruia se consideră check-in-ul angajaților pentru participare.,
+Allow check-out after shift end time (in minutes),Permite check-out după ora de încheiere a schimbului (în minute),
+Time after the end of shift during which check-out is considered for attendance.,Timpul după încheierea turei în timpul căreia se face check-out pentru participare.,
+Working Hours Threshold for Half Day,Prag de lucru pentru o jumătate de zi,
+Working hours below which Half Day is marked. (Zero to disable),Ore de lucru sub care este marcată jumătate de zi. (Zero dezactivat),
+Working Hours Threshold for Absent,Prag de lucru pentru orele absente,
+Working hours below which Absent is marked. (Zero to disable),Ore de lucru sub care este marcat absentul. (Zero dezactivat),
+Process Attendance After,Prezență la proces după,
+Attendance will be marked automatically only after this date.,Participarea va fi marcată automat numai după această dată.,
+Last Sync of Checkin,Ultima sincronizare a checkin-ului,
+Last Known Successful Sync of Employee Checkin. Reset this only if you are sure that all Logs are synced from all the locations. Please don't modify this if you are unsure.,Ultima sincronizare cunoscută cu succes a verificării angajaților. Resetați acest lucru numai dacă sunteți sigur că toate jurnalele sunt sincronizate din toate locațiile. Vă rugăm să nu modificați acest lucru dacă nu sunteți sigur.,
+Grace Period Settings For Auto Attendance,Setări pentru perioada de grație pentru prezența automată,
+Enable Entry Grace Period,Activați perioada de grație de intrare,
+Late Entry Grace Period,Perioada de grație de intrare târzie,
+The time after the shift start time when check-in is considered as late (in minutes).,"Ora după ora de începere a schimbului, când check-in este considerată întârziată (în minute).",
+Enable Exit Grace Period,Activați Perioada de grație de ieșire,
+Early Exit Grace Period,Perioada de grație de ieșire timpurie,
+The time before the shift end time when check-out is considered as early (in minutes).,"Timpul înainte de ora de încheiere a schimbului, când check-out-ul este considerat mai devreme (în minute).",
+Skill Name,Nume de îndemânare,
+Staffing Plan Details,Detaliile planului de personal,
+Staffing Plan Detail,Detaliile planului de personal,
+Total Estimated Budget,Bugetul total estimat,
+Vacancies,Posturi vacante,
+Estimated Cost Per Position,Costul estimat pe poziție,
+Total Estimated Cost,Costul total estimat,
+Current Count,Contorul curent,
+Current Openings,Deschideri curente,
+Number Of Positions,Numărul de poziții,
+Taxable Salary Slab,Taxable Salary Slab,
+From Amount,Din Sumă,
+To Amount,La suma,
+Percent Deduction,Deducție procentuală,
+Training Program,Program de antrenament,
+Event Status,Stare eveniment,
+Has Certificate,Are certificat,
+Seminar,Seminar,
+Theory,Teorie,
+Workshop,Atelier,
+Conference,Conferinţă,
+Exam,Examen,
+Internet,Internet,
+Self-Study,Studiu individual,
+Advance,Avans,
+Trainer Name,Nume formator,
+Trainer Email,trainer e-mail,
+Attendees,Participanți,
+Employee Emails,E-mailuri ale angajaților,
+Training Event Employee,Eveniment de formare Angajat,
+Invited,invitați,
+Feedback Submitted,Feedbackul a fost trimis,
+Optional,facultativ,
+Training Result Employee,Angajat de formare Rezultat,
+Travel Itinerary,Itinerariul de călătorie,
+Travel From,Călătorie de la,
+Travel To,Călători în,
+Mode of Travel,Modul de călătorie,
+Flight,Zbor,
+Train,Tren,
+Taxi,Taxi,
+Rented Car,Mașină închiriată,
+Meal Preference,Preferința de mâncare,
+Vegetarian,Vegetarian,
+Non-Vegetarian,Non vegetarian,
+Gluten Free,Fara gluten,
+Non Diary,Non-jurnal,
+Travel Advance Required,Advance Travel Required,
+Departure Datetime,Data plecării,
+Arrival Datetime,Ora de sosire,
+Lodging Required,Cazare solicitată,
+Preferred Area for Lodging,Zonă preferată de cazare,
+Check-in Date,Data înscrierii,
+Check-out Date,Verifica data,
+Travel Request,Cerere de călătorie,
+Travel Type,Tip de călătorie,
+Domestic,Intern,
+International,Internaţional,
+Travel Funding,Finanțarea turismului,
+Require Full Funding,Solicitați o finanțare completă,
+Fully Sponsored,Sponsorizat complet,
+"Partially Sponsored, Require Partial Funding","Parțial sponsorizat, necesită finanțare parțială",
+Copy of Invitation/Announcement,Copia invitatiei / anuntului,
+"Details of Sponsor (Name, Location)","Detalii despre sponsor (nume, locație)",
+Identification Document Number,Cod Numeric Personal,
+Any other details,Orice alte detalii,
+Costing Details,Costul detaliilor,
+Costing,Cost,
+Event Details,detaliile evenimentului,
+Name of Organizer,Numele organizatorului,
+Address of Organizer,Adresa organizatorului,
+Travel Request Costing,Costul cererii de călătorie,
+Expense Type,Tipul de cheltuieli,
+Sponsored Amount,Suma sponsorizată,
+Funded Amount,Sumă finanțată,
+Upload Attendance,Încărcați Spectatori,
+Attendance From Date,Prezenţa de la data,
+Attendance To Date,Prezenţa până la data,
+Get Template,Obține șablon,
+Import Attendance,Import Spectatori,
+Upload HTML,Încărcați HTML,
+Vehicle,Vehicul,
+License Plate,Înmatriculare,
+Odometer Value (Last),Valoarea contorului de parcurs (Ultimul),
+Acquisition Date,Data achiziției,
+Chassis No,Nr. Șasiu,
+Vehicle Value,Valoarea vehiculului,
+Insurance Details,Detalii de asigurare,
+Insurance Company,Companie de asigurari,
+Policy No,Politica nr,
+Additional Details,Detalii suplimentare,
+Fuel Type,Tipul combustibilului,
+Petrol,Benzină,
+Diesel,Diesel,
+Natural Gas,Gaz natural,
+Electric,Electric,
+Fuel UOM,combustibil UOM,
+Last Carbon Check,Ultima Verificare carbon,
+Wheels,roţi,
+Doors,Usi,
+HR-VLOG-.YYYY.-,HR-VLOG-.YYYY.-,
+Odometer Reading,Kilometrajul,
+Current Odometer value ,Valoarea actuală a contorului,
+last Odometer Value ,ultima valoare Odometru,
+Refuelling Details,Detalii de realimentare,
+Invoice Ref,Ref factură,
+Service Details,Detalii de serviciu,
+Service Detail,Detaliu serviciu,
+Vehicle Service,Serviciu de vehicule,
+Service Item,Postul de servicii,
+Brake Oil,Ulei de frână,
+Brake Pad,Pad de frână,
+Clutch Plate,Placă de ambreiaj,
+Engine Oil,Ulei de motor,
+Oil Change,Schimbare de ulei,
+Inspection,Inspecţie,
+Mileage,distanță parcursă,
+Hub Tracked Item,Articol urmărit,
+Hub Node,Hub Node,
+Image List,Listă de imagini,
+Item Manager,Postul de manager,
+Hub User,Utilizator Hub,
+Hub Password,Parola Hub,
+Hub Users,Hub utilizatori,
+Marketplace Settings,Setări pentru piață,
+Disable Marketplace,Dezactivați Marketplace,
+Marketplace URL (to hide and update label),Adresa URL de pe piață (pentru ascunderea și actualizarea etichetei),
+Registered,Înregistrat,
+Sync in Progress,Sincronizați în curs,
+Hub Seller Name,Numele vânzătorului Hub,
+Custom Data,Date personalizate,
+Member,Membru,
+Partially Disbursed,parţial Se eliberează,
+Loan Closure Requested,Solicitare de închidere a împrumutului,
+Repay From Salary,Rambursa din salariu,
+Loan Details,Creditul Detalii,
+Loan Type,Tip credit,
+Loan Amount,Sumă împrumutată,
+Is Secured Loan,Este împrumut garantat,
+Rate of Interest (%) / Year,Rata dobânzii (%) / An,
+Disbursement Date,debursare,
+Disbursed Amount,Suma plătită,
+Is Term Loan,Este împrumut pe termen,
+Repayment Method,Metoda de rambursare,
+Repay Fixed Amount per Period,Rambursa Suma fixă pentru fiecare perioadă,
+Repay Over Number of Periods,Rambursa Peste Număr de Perioade,
+Repayment Period in Months,Rambursarea Perioada în luni,
+Monthly Repayment Amount,Suma de rambursare lunar,
+Repayment Start Date,Data de începere a rambursării,
+Loan Security Details,Detalii privind securitatea împrumutului,
+Maximum Loan Value,Valoarea maximă a împrumutului,
+Account Info,Informaţii cont,
+Loan Account,Contul împrumutului,
+Interest Income Account,Contul Interes Venit,
+Penalty Income Account,Cont de venituri din penalități,
+Repayment Schedule,rambursare Program,
+Total Payable Amount,Suma totală de plată,
+Total Principal Paid,Total plătit principal,
+Total Interest Payable,Dobânda totală de plată,
+Total Amount Paid,Suma totală plătită,
+Loan Manager,Managerul de împrumut,
+Loan Info,Creditul Info,
+Rate of Interest,Rata Dobânzii,
+Proposed Pledges,Promisiuni propuse,
+Maximum Loan Amount,Suma maximă a împrumutului,
+Repayment Info,Info rambursarea,
+Total Payable Interest,Dobânda totală de plată,
+Against Loan ,Împotriva împrumutului,
+Loan Interest Accrual,Dobândirea dobânzii împrumutului,
+Amounts,sume,
+Pending Principal Amount,Suma pendintei principale,
+Payable Principal Amount,Suma principală plătibilă,
+Paid Principal Amount,Suma principală plătită,
+Paid Interest Amount,Suma dobânzii plătite,
+Process Loan Interest Accrual,Procesul de dobândă de împrumut,
+Repayment Schedule Name,Numele programului de rambursare,
+Regular Payment,Plată regulată,
+Loan Closure,Închiderea împrumutului,
+Payment Details,Detalii de plata,
+Interest Payable,Dobândi de plătit,
+Amount Paid,Sumă plătită,
+Principal Amount Paid,Suma principală plătită,
+Repayment Details,Detalii de rambursare,
+Loan Repayment Detail,Detaliu rambursare împrumut,
+Loan Security Name,Numele securității împrumutului,
+Unit Of Measure,Unitate de măsură,
+Loan Security Code,Codul de securitate al împrumutului,
+Loan Security Type,Tip de securitate împrumut,
+Haircut %,Tunsori%,
+Loan  Details,Detalii despre împrumut,
+Unpledged,Unpledged,
+Pledged,gajat,
+Partially Pledged,Parțial Gajat,
+Securities,Titluri de valoare,
+Total Security Value,Valoarea totală a securității,
+Loan Security Shortfall,Deficitul de securitate al împrumutului,
+Loan ,Împrumut,
+Shortfall Time,Timpul neajunsurilor,
+America/New_York,America / New_York,
+Shortfall Amount,Suma deficiențelor,
+Security Value ,Valoarea de securitate,
+Process Loan Security Shortfall,Deficitul de securitate a împrumutului de proces,
+Loan To Value Ratio,Raportul împrumut / valoare,
+Unpledge Time,Timp de neîncărcare,
+Loan Name,Nume de împrumut,
+Rate of Interest (%) Yearly,Rata Dobânzii (%) Anual,
+Penalty Interest Rate (%) Per Day,Rata dobânzii de penalizare (%) pe zi,
+Penalty Interest Rate is levied on the pending interest amount on a daily basis in case of delayed repayment ,Rata dobânzii pentru penalități este percepută zilnic pe valoarea dobânzii în curs de rambursare întârziată,
+Grace Period in Days,Perioada de har în zile,
+No. of days from due date until which penalty won't be charged in case of delay in loan repayment,Numărul de zile de la data scadenței până la care nu se va percepe penalitatea în cazul întârzierii rambursării împrumutului,
+Pledge,Angajament,
+Post Haircut Amount,Postează cantitatea de tuns,
+Process Type,Tipul procesului,
+Update Time,Timpul de actualizare,
+Proposed Pledge,Gajă propusă,
+Total Payment,Plată totală,
+Balance Loan Amount,Soldul Suma creditului,
+Is Accrued,Este acumulat,
+Salary Slip Loan,Salariu Slip împrumut,
+Loan Repayment Entry,Intrarea rambursării împrumutului,
+Sanctioned Loan Amount,Suma de împrumut sancționată,
+Sanctioned Amount Limit,Limita sumei sancționate,
+Unpledge,Unpledge,
+Haircut,Tunsoare,
+MAT-MSH-.YYYY.-,MAT-MSH-.YYYY.-,
+Generate Schedule,Generează orar,
+Schedules,Orarele,
+Maintenance Schedule Detail,Detalii Program Mentenanta,
+Scheduled Date,Data programată,
+Actual Date,Data efectiva,
+Maintenance Schedule Item,Articol Program Mentenanță,
+Random,aleatoriu,
+No of Visits,Nu de vizite,
+MAT-MVS-.YYYY.-,MAT-MVS-.YYYY.-,
+Maintenance Date,Dată Mentenanță,
+Maintenance Time,Timp Mentenanta,
+Completion Status,Stare Finalizare,
+Partially Completed,Parțial finalizate,
+Fully Completed,Finalizat,
+Unscheduled,Neprogramat,
+Breakdown,Avarie,
+Purposes,Scopuri,
+Customer Feedback,Feedback Client,
+Maintenance Visit Purpose,Scop Vizită Mentenanță,
+Work Done,Activitatea desfășurată,
+Against Document No,Împotriva documentul nr,
+Against Document Detail No,Comparativ detaliilor documentului nr.,
+MFG-BLR-.YYYY.-,MFG-BLR-.YYYY.-,
+Order Type,Tip comandă,
+Blanket Order Item,Articol de comandă pentru plicuri,
+Ordered Quantity,Ordonat Cantitate,
+Item to be manufactured or repacked,Articol care urmează să fie fabricat sau reambalat,
+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,
+Set rate of sub-assembly item based on BOM,Viteza setată a elementului subansamblu bazat pe BOM,
+Allow Alternative Item,Permiteți un element alternativ,
+Item UOM,Articol FDM,
+Conversion Rate,Rata de conversie,
+Rate Of Materials Based On,Rate de materiale bazate pe,
+With Operations,Cu Operațiuni,
+Manage cost of operations,Gestionează costul operațiunilor,
+Transfer Material Against,Transfer material contra,
+Routing,Rutare,
+Materials,Materiale,
+Quality Inspection Required,Inspecție de calitate necesară,
+Quality Inspection Template,Model de inspecție a calității,
+Scrap,Resturi,
+Scrap Items,resturi Articole,
+Operating Cost,Costul de operare,
+Raw Material Cost,Cost Materie Primă,
+Scrap Material Cost,Cost resturi de materiale,
+Operating Cost (Company Currency),Costul de operare (Companie Moneda),
+Raw Material Cost (Company Currency),Costul materiei prime (moneda companiei),
+Scrap Material Cost(Company Currency),Cost resturi de material (companie Moneda),
+Total Cost,Cost total,
+Total Cost (Company Currency),Cost total (moneda companiei),
+Materials Required (Exploded),Materiale necesare (explodat),
+Exploded Items,Articole explozibile,
+Show in Website,Afișați pe site,
+Item Image (if not slideshow),Imagine Articol (dacă nu exista prezentare),
+Thumbnail,Miniatură,
+Website Specifications,Site-ul Specificații,
+Show Items,Afișare articole,
+Show Operations,Afișați Operații,
+Website Description,Site-ul Descriere,
+BOM Explosion Item,Explozie articol BOM,
+Qty Consumed Per Unit,Cantitate consumata pe unitatea,
+Include Item In Manufacturing,Includeți articole în fabricație,
+BOM Item,Articol BOM,
+Item operation,Operarea elementului,
+Rate & Amount,Rata și suma,
+Basic Rate (Company Currency),Rată elementară (moneda companiei),
+Scrap %,Resturi%,
+Original Item,Articolul original,
+BOM Operation,Operațiune BOM,
+Operation Time ,Timpul de funcționare,
+In minutes,În câteva minute,
+Batch Size,Mărimea lotului,
+Base Hour Rate(Company Currency),Rata de bază ore (companie Moneda),
+Operating Cost(Company Currency),Costul de operare (Companie Moneda),
+BOM Scrap Item,BOM Resturi Postul,
+Basic Amount (Company Currency),Suma de bază (Companie Moneda),
+BOM Update Tool,Instrument Actualizare BOM,
+"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.\nIt also updates latest price in all the BOMs.","Înlocuiți un BOM particular în toate celelalte BOM unde este utilizat. Acesta va înlocui vechiul link BOM, va actualiza costul și va regenera tabelul &quot;BOM Explosion Item&quot; ca pe noul BOM. Actualizează, de asemenea, ultimul preț în toate BOM-urile.",
+Replace BOM,Înlocuiește BOM,
+Current BOM,FDM curent,
+The BOM which will be replaced,BOM care va fi înlocuit,
+The new BOM after replacement,Noul BOM după înlocuirea,
+Replace,Înlocuiește,
+Update latest price in all BOMs,Actualizați cel mai recent preț în toate BOM-urile,
+BOM Website Item,Site-ul BOM Articol,
+BOM Website Operation,Site-ul BOM Funcționare,
+Operation Time,Funcționare Ora,
+PO-JOB.#####,PO-JOB. #####,
+Timing Detail,Detalii detaliate,
+Time Logs,Timp Busteni,
+Total Time in Mins,Timp total în mină,
+Operation ID,ID operațiune,
+Transferred Qty,Transferat Cantitate,
+Job Started,Job a început,
+Started Time,Timpul început,
+Current Time,Ora curentă,
+Job Card Item,Cartelă de posturi,
+Job Card Time Log,Jurnalul de timp al cărții de lucru,
+Time In Mins,Timpul în min,
+Completed Qty,Cantitate Finalizata,
+Manufacturing Settings,Setări de Fabricație,
+Raw Materials Consumption,Consumul de materii prime,
+Allow Multiple Material Consumption,Permiteți consumul mai multor materiale,
+Backflush Raw Materials Based On,Backflush Materii Prime bazat pe,
+Material Transferred for Manufacture,Material Transferat pentru fabricarea,
+Capacity Planning,Planificarea capacității,
+Disable Capacity Planning,Dezactivează planificarea capacității,
+Allow Overtime,Permiteți ore suplimentare,
+Allow Production on Holidays,Permiteţi operaţii de producție pe durata sărbătorilor,
+Capacity Planning For (Days),Planificarea capacitate de (zile),
+Default Warehouses for Production,Depozite implicite pentru producție,
+Default Work In Progress Warehouse,Implicit Lucrări în depozit Progress,
+Default Finished Goods Warehouse,Implicite terminat Marfuri Warehouse,
+Default Scrap Warehouse,Depozitul de resturi implicit,
+Overproduction Percentage For Sales Order,Procentaj de supraproducție pentru comandă de vânzări,
+Overproduction Percentage For Work Order,Procentul de supraproducție pentru comanda de lucru,
+Other Settings,alte setări,
+Update BOM Cost Automatically,Actualizați costul BOM automat,
+Material Request Plan Item,Material Cerere plan plan,
+Material Request Type,Material Cerere tip,
+Material Issue,Problema de material,
+Customer Provided,Client oferit,
+Minimum Order Quantity,Cantitatea minima pentru comanda,
+Default Workstation,Implicit Workstation,
+Production Plan,Plan de productie,
+MFG-PP-.YYYY.-,MFG-PP-.YYYY.-,
+Get Items From,Obține elemente din,
+Get Sales Orders,Obține comenzile de vânzări,
+Material Request Detail,Detalii privind solicitarea materialului,
+Get Material Request,Material Cerere obțineți,
+Material Requests,Cereri de materiale,
+Get Items For Work Order,Obțineți comenzi pentru lucru,
+Material Request Planning,Planificarea solicitărilor materiale,
+Include Non Stock Items,Includeți articole din stoc,
+Include Subcontracted Items,Includeți articole subcontractate,
+Ignore Existing Projected Quantity,Ignorați cantitatea proiectată existentă,
+"To know more about projected quantity, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">click here</a>.","Pentru a afla mai multe despre cantitatea proiectată, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">faceți clic aici</a> .",
+Download Required Materials,Descărcați materialele necesare,
+Get Raw Materials For Production,Obțineți materii prime pentru producție,
+Total Planned Qty,Cantitatea totală planificată,
+Total Produced Qty,Cantitate total produsă,
+Material Requested,Material solicitat,
+Production Plan Item,Planul de producție Articol,
+Make Work Order for Sub Assembly Items,Realizați comanda de lucru pentru articolele de subansamblare,
+"If enabled, system will create the work order for the exploded items against which BOM is available.","Dacă este activat, sistemul va crea ordinea de lucru pentru elementele explodate pentru care este disponibilă BOM.",
+Planned Start Date,Start data planificată,
+Quantity and Description,Cantitate și descriere,
+material_request_item,material_request_item,
+Product Bundle Item,Produs Bundle Postul,
+Production Plan Material Request,Producția Plan de material Cerere,
+Production Plan Sales Order,Planul de producție comandă de vânzări,
+Sales Order Date,Comandă de vânzări Data,
+Routing Name,Numele de rutare,
+MFG-WO-.YYYY.-,MFG-WO-.YYYY.-,
+Item To Manufacture,Articol pentru Fabricare,
+Material Transferred for Manufacturing,Materii Transferate pentru fabricarea,
+Manufactured Qty,Cantitate Produsă,
+Use Multi-Level BOM,Utilizarea Multi-Level BOM,
+Plan material for sub-assemblies,Material Plan de subansambluri,
+Skip Material Transfer to WIP Warehouse,Treceți transferul de materiale la WIP Warehouse,
+Check if material transfer entry is not required,Verificați dacă nu este necesară introducerea transferului de materiale,
+Backflush Raw Materials From Work-in-Progress Warehouse,Materii prime de tip backflush din depozitul &quot;work-in-progress&quot;,
+Update Consumed Material Cost In Project,Actualizați costurile materialelor consumate în proiect,
+Warehouses,Depozite,
+This is a location where raw materials are available.,Acesta este un loc unde materiile prime sunt disponibile.,
+Work-in-Progress Warehouse,Depozit Lucru-în-Progres,
+This is a location where operations are executed.,Aceasta este o locație în care se execută operațiuni.,
+This is a location where final product stored.,Aceasta este o locație în care este depozitat produsul final.,
+Scrap Warehouse,Depozit fier vechi,
+This is a location where scraped materials are stored.,Aceasta este o locație în care sunt depozitate materiale razuite.,
+Required Items,Articole cerute,
+Actual Start Date,Dată Efectivă de Început,
+Planned End Date,Planificate Data de încheiere,
+Actual End Date,Data efectiva de finalizare,
+Operation Cost,Funcționare cost,
+Planned Operating Cost,Planificate cost de operare,
+Actual Operating Cost,Cost efectiv de operare,
+Additional Operating Cost,Costuri de operare adiţionale,
+Total Operating Cost,Cost total de operare,
+Manufacture against Material Request,Fabricare împotriva Cerere Material,
+Work Order Item,Postul de comandă de lucru,
+Available Qty at Source Warehouse,Cantitate disponibilă la Warehouse sursă,
+Available Qty at WIP Warehouse,Cantitate disponibilă la WIP Warehouse,
+Work Order Operation,Comandă de comandă de lucru,
+Operation Description,Operație Descriere,
+Operation completed for how many finished goods?,Funcționare completat de cât de multe bunuri finite?,
+Work in Progress,Lucrări în curs,
+Estimated Time and Cost,Timpul estimat și cost,
+Planned Start Time,Planificate Ora de începere,
+Planned End Time,Planificate End Time,
+in Minutes,In cateva minute,
+Actual Time and Cost,Timp și cost efective,
+Actual Start Time,Timpul efectiv de începere,
+Actual End Time,Timp efectiv de sfârşit,
+Updated via 'Time Log',"Actualizat prin ""Ora Log""",
+Actual Operation Time,Timp efectiv de funcționare,
+in Minutes\nUpdated via 'Time Log',"în procesul-verbal \n Actualizat prin ""Ora Log""",
+(Hour Rate / 60) * Actual Operation Time,(Tarif orar / 60) * Timp efectiv de operare,
+Workstation Name,Stație de lucru Nume,
+Production Capacity,Capacitatea de producție,
+Operating Costs,Costuri de operare,
+Electricity Cost,Cost energie electrică,
+per hour,pe oră,
+Consumable Cost,Cost Consumabile,
+Rent Cost,Cost Chirie,
+Wages,Salarizare,
+Wages per hour,Salarii pe oră,
+Net Hour Rate,Net Rata de ore,
+Workstation Working Hour,Statie de lucru de ore de lucru,
+Certification Application,Cerere de certificare,
+Name of Applicant,Numele aplicantului,
+Certification Status,Stare Certificare,
+Yet to appear,"Totuși, să apară",
+Certified,Certificat,
+Not Certified,Nu este certificată,
+USD,USD,
+INR,INR,
+Certified Consultant,Consultant Certificat,
+Name of Consultant,Numele consultantului,
+Certification Validity,Valabilitatea Certificare,
+Discuss ID,Discutați ID-ul,
+GitHub ID,ID-ul GitHub,
+Non Profit Manager,Manager non-profit,
+Chapter Head,Capitolul Cap,
+Meetup Embed HTML,Meetup Embed HTML,
+chapters/chapter_name\nleave blank automatically set after saving chapter.,capitole / nume_capitale lasă setul automat să fie setat automat după salvarea capitolului.,
+Chapter Members,Capitolul Membri,
+Members,Membrii,
+Chapter Member,Membru de capitol,
+Website URL,Website URL,
+Leave Reason,Lăsați rațiunea,
+Donor Name,Numele donatorului,
+Donor Type,Tipul donatorului,
+Withdrawn,retrasă,
+Grant Application Details ,Detalii privind cererile de finanțare,
+Grant Description,Descrierea granturilor,
+Requested Amount,Suma solicitată,
+Has any past Grant Record,Are vreun dosar Grant trecut,
+Show on Website,Afișați pe site,
+Assessment  Mark (Out of 10),Marca de evaluare (din 10),
+Assessment  Manager,Manager de evaluare,
+Email Notification Sent,Trimiterea notificării prin e-mail,
+NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-,
+Membership Expiry Date,Data expirării membrilor,
+Razorpay Details,Detalii Razorpay,
+Subscription ID,ID-ul abonamentului,
+Customer ID,Număr de înregistrare client,
+Subscription Activated,Abonament activat,
+Subscription Start ,Începere abonament,
+Subscription End,Încheierea abonamentului,
+Non Profit Member,Membru non-profit,
+Membership Status,Statutul de membru,
+Member Since,Membru din,
+Payment ID,ID de plată,
+Membership Settings,Setări de membru,
+Enable RazorPay For Memberships,Activați RazorPay pentru calitatea de membru,
+RazorPay Settings,Setări RazorPay,
+Billing Cycle,Ciclu de facturare,
+Billing Frequency,Frecvența de facturare,
+"The number of billing cycles for which the customer should be charged. For example, if a customer is buying a 1-year membership that should be billed on a monthly basis, this value should be 12.","Numărul de cicluri de facturare pentru care ar trebui să fie taxat clientul. De exemplu, dacă un client cumpără un abonament de 1 an care ar trebui să fie facturat lunar, această valoare ar trebui să fie 12.",
+Razorpay Plan ID,ID-ul planului Razorpay,
+Volunteer Name,Nume de voluntar,
+Volunteer Type,Tipul de voluntari,
+Availability and Skills,Disponibilitate și abilități,
+Availability,Disponibilitate,
+Weekends,Weekend-uri,
+Availability Timeslot,Disponibilitatea Timeslot,
+Morning,Dimineaţă,
+Afternoon,Dupa amiaza,
+Evening,Seară,
+Anytime,Oricând,
+Volunteer Skills,Abilități de voluntariat,
+Volunteer Skill,Abilități de voluntariat,
+Homepage,Pagina Principală,
+Hero Section Based On,Secția Eroilor Bazată pe,
+Homepage Section,Secțiunea Prima pagină,
+Hero Section,Secția Eroilor,
+Tag Line,Eticheta linie,
+Company Tagline for website homepage,Firma Tagline pentru pagina de start site,
+Company Description for website homepage,Descriere companie pentru pagina de start site,
+Homepage Slideshow,Prezentare Slideshow a paginii de start,
+"URL for ""All Products""",URL-ul pentru &quot;Toate produsele&quot;,
+Products to be shown on website homepage,Produsele care urmează să fie afișate pe pagina de pornire site,
+Homepage Featured Product,Pagina de intrare de produse recomandate,
+route,traseu,
+Section Based On,Secțiune bazată pe,
+Section Cards,Cărți de secțiune,
+Number of Columns,Numar de coloane,
+Number of columns for this section. 3 cards will be shown per row if you select 3 columns.,Numărul de coloane pentru această secțiune. 3 cărți vor fi afișate pe rând dacă selectați 3 coloane.,
+Section HTML,Secțiunea HTML,
+Use this field to render any custom HTML in the section.,Utilizați acest câmp pentru a reda orice HTML personalizat în secțiune.,
+Section Order,Comanda secțiunii,
+"Order in which sections should appear. 0 is first, 1 is second and so on.","Ordinea în care ar trebui să apară secțiunile. 0 este primul, 1 este al doilea și așa mai departe.",
+Homepage Section Card,Pagina de secțiune Card de secțiune,
+Subtitle,Subtitlu,
+Products Settings,produse Setări,
+Home Page is Products,Pagina Principală este Produse,
+"If checked, the Home page will be the default Item Group for the website","Dacă este bifată, pagina de pornire va fi implicit postul Grupului pentru site-ul web",
+Show Availability Status,Afișați starea de disponibilitate,
+Product Page,Pagina produsului,
+Products per Page,Produse pe Pagină,
+Enable Field Filters,Activați filtrele de câmp,
+Item Fields,Câmpurile articolului,
+Enable Attribute Filters,Activați filtrele de atribute,
+Attributes,Atribute,
+Hide Variants,Ascundeți variantele,
+Website Attribute,Atribut site web,
+Attribute,Atribute,
+Website Filter Field,Câmpul de filtrare a site-ului web,
+Activity Cost,Cost activitate,
+Billing Rate,Tarif de facturare,
+Costing Rate,Costing Rate,
+title,titlu,
+Projects User,Utilizator Proiecte,
+Default Costing Rate,Rată Cost Implicit,
+Default Billing Rate,Tarif de Facturare Implicit,
+Dependent Task,Sarcina dependent,
+Project Type,Tip de proiect,
+% Complete Method,% Metoda completă,
+Task Completion,sarcina Finalizarea,
+Task Progress,Progresul sarcină,
+% Completed,% Finalizat,
+From Template,Din șablon,
+Project will be accessible on the website to these users,Proiectul va fi accesibil pe site-ul acestor utilizatori,
+Copied From,Copiat de la,
+Start and End Dates,Începere și de încheiere Date,
+Actual Time (in Hours),Ora reală (în ore),
+Costing and Billing,Calculație a cheltuielilor și veniturilor,
+Total Costing Amount (via Timesheets),Suma totală a costurilor (prin intermediul foilor de pontaj),
+Total Expense Claim (via Expense Claims),Revendicarea Total cheltuieli (prin formularele de decont),
+Total Purchase Cost (via Purchase Invoice),Cost total de achiziție (prin cumparare factură),
+Total Sales Amount (via Sales Order),Suma totală a vânzărilor (prin comandă de vânzări),
+Total Billable Amount (via Timesheets),Sumă totală facturată (prin intermediul foilor de pontaj),
+Total Billed Amount (via Sales Invoices),Suma facturată totală (prin facturi de vânzare),
+Total Consumed Material Cost  (via Stock Entry),Costul total al materialelor consumate (prin intrarea în stoc),
+Gross Margin,Marja Brută,
+Gross Margin %,Marja Bruta%,
+Monitor Progress,Monitorizați progresul,
+Collect Progress,Collect Progress,
+Frequency To Collect Progress,Frecventa de colectare a progresului,
+Twice Daily,De doua ori pe zi,
+First Email,Primul e-mail,
+Second Email,Al doilea e-mail,
+Time to send,Este timpul să trimiteți,
+Day to Send,Zi de Trimis,
+Message will be sent to the users to get their status on the Project,Mesajul va fi trimis utilizatorilor pentru a obține starea lor în Proiect,
+Projects Manager,Manager Proiecte,
+Project Template,Model de proiect,
+Project Template Task,Sarcina șablonului de proiect,
+Begin On (Days),Începeți (zile),
+Duration (Days),Durata (zile),
+Project Update,Actualizarea proiectului,
+Project User,utilizator proiect,
+View attachments,Vizualizați atașamentele,
+Projects Settings,Setări pentru proiecte,
+Ignore Workstation Time Overlap,Ignorați suprapunerea timpului de lucru al stației,
+Ignore User Time Overlap,Ignorați timpul suprapunerii utilizatorului,
+Ignore Employee Time Overlap,Ignorați suprapunerea timpului angajatului,
+Weight,Greutate,
+Parent Task,Activitatea părintească,
+Timeline,Cronologie,
+Expected Time (in hours),Timp de așteptat (în ore),
+% Progress,% Progres,
+Is Milestone,Este Milestone,
+Task Description,Descrierea sarcinii,
+Dependencies,dependenţe,
+Dependent Tasks,Sarcini dependente,
+Depends on Tasks,Depinde de Sarcini,
+Actual Start Date (via Time Sheet),Data Efectiva de Început (prin Pontaj),
+Actual Time (in hours),Timpul efectiv (în ore),
+Actual End Date (via Time Sheet),Dată de Încheiere Efectivă (prin Pontaj),
+Total Costing Amount (via Time Sheet),Suma totală de calculație a costurilor (prin timp Sheet),
+Total Expense Claim (via Expense Claim),Revendicarea Total cheltuieli (prin cheltuieli revendicarea),
+Total Billing Amount (via Time Sheet),Suma totală de facturare (prin timp Sheet),
+Review Date,Data Comentariului,
+Closing Date,Data de Inchidere,
+Task Depends On,Sarcina Depinde,
+Task Type,Tipul sarcinii,
+TS-.YYYY.-,TS-.YYYY.-,
+Employee Detail,Detaliu angajat,
+Billing Details,Detalii de facturare,
+Total Billable Hours,Numărul total de ore facturabile,
+Total Billed Hours,Numărul total de ore facturate,
+Total Costing Amount,Suma totală Costing,
+Total Billable Amount,Suma totală Taxabil,
+Total Billed Amount,Suma totală Billed,
+% Amount Billed,% Suma facturata,
+Hrs,ore,
+Costing Amount,Costing Suma,
+Corrective/Preventive,Corectivă / preventivă,
+Corrective,corectiv,
+Preventive,Preventiv,
+Resolution,Rezoluție,
+Resolutions,rezoluţiile,
+Quality Action Resolution,Rezolvare acțiuni de calitate,
+Quality Feedback Parameter,Parametru de feedback al calității,
+Quality Feedback Template Parameter,Parametrul șablonului de feedback al calității,
+Quality Goal,Obiectivul de calitate,
+Monitoring Frequency,Frecvența de monitorizare,
+Weekday,zi de lucru,
+Objectives,Obiective,
+Quality Goal Objective,Obiectivul calității,
+Objective,Obiectiv,
+Agenda,Agendă,
+Minutes,Minute,
+Quality Meeting Agenda,Agenda întâlnirii de calitate,
+Quality Meeting Minutes,Proces-verbal de calitate al întâlnirii,
+Minute,Minut,
+Parent Procedure,Procedura părinților,
+Processes,procese,
+Quality Procedure Process,Procesul procedurii de calitate,
+Process Description,Descrierea procesului,
+Link existing Quality Procedure.,Conectați procedura de calitate existentă.,
+Additional Information,informatii suplimentare,
+Quality Review Objective,Obiectivul revizuirii calității,
+DATEV Settings,Setări DATEV,
+Regional,Regional,
+Consultant ID,ID-ul consultantului,
+GST HSN Code,Codul GST HSN,
+HSN Code,Codul HSN,
+GST Settings,Setări GST,
+GST Summary,Rezumatul GST,
+GSTIN Email Sent On,GSTIN Email trimis pe,
+GST Accounts,Conturi GST,
+B2C Limit,Limita B2C,
+Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Setați valoarea facturii pentru B2C. B2CL și B2CS calculate pe baza acestei valori de facturare.,
+GSTR 3B Report,Raportul GSTR 3B,
+January,ianuarie,
+February,februarie,
+March,Martie,
+April,Aprilie,
+May,Mai,
+June,iunie,
+July,iulie,
+August,August,
+September,Septembrie,
+October,octombrie,
+November,noiembrie,
+December,decembrie,
+JSON Output,Ieșire JSON,
+Invoices with no Place Of Supply,Facturi fără loc de furnizare,
+Import Supplier Invoice,Import factură furnizor,
+Invoice Series,Seria facturilor,
+Upload XML Invoices,Încărcați facturile XML,
+Zip File,Fișier Zip,
+Import Invoices,Importul facturilor,
+Click on Import Invoices button once the zip file has been attached to the document. Any errors related to processing will be shown in the Error Log.,Faceți clic pe butonul Import facturi după ce fișierul zip a fost atașat la document. Orice erori legate de procesare vor fi afișate în Jurnalul de erori.,
+Lower Deduction Certificate,Certificat de deducere inferior,
+Certificate Details,Detalii certificat,
+194A,194A,
+194C,194C,
+194D,194D,
+194H,194H,
+194I,194I,
+194J,194J,
+194LA,194LA,
+194LBB,194LBB,
+194LBC,194LBC,
+Certificate No,număr de certificat,
+Deductee Details,Detalii despre deducere,
+PAN No,PAN nr,
+Validity Details,Detalii de valabilitate,
+Rate Of TDS As Per Certificate,Rata TDS conform certificatului,
+Certificate Limit,Limita certificatului,
+Invoice Series Prefix,Prefixul seriei de facturi,
+Active Menu,Meniul activ,
+Restaurant Menu,Meniu Restaurant,
+Price List (Auto created),Listă Prețuri (creată automat),
+Restaurant Manager,Manager Restaurant,
+Restaurant Menu Item,Articol Meniu Restaurant,
+Restaurant Order Entry,Intrare comandă de restaurant,
+Restaurant Table,Masă Restaurant,
+Click Enter To Add,Faceți clic pe Enter to Add,
+Last Sales Invoice,Ultima factură de vânzare,
+Current Order,Comanda actuală,
+Restaurant Order Entry Item,Articol de intrare pentru comandă pentru restaurant,
+Served,servit,
+Restaurant Reservation,Rezervare la restaurant,
+Waitlisted,waitlisted,
+No Show,Neprezentare,
+No of People,Nr de oameni,
+Reservation Time,Timp de rezervare,
+Reservation End Time,Timp de terminare a rezervării,
+No of Seats,Numărul de scaune,
+Minimum Seating,Scaunele minime,
+"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment. ","Păstra Tractor de campanii de vanzari. Țineți evidența de afaceri, Cotațiile, comandă de vânzări, etc de la Campanii pentru a evalua Return on Investment.",
+SAL-CAM-.YYYY.-,SAL-CAM-.YYYY.-,
+Campaign Schedules,Programele campaniei,
+Buyer of Goods and Services.,Cumpărător de produse și servicii.,
+CUST-.YYYY.-,CUST-.YYYY.-,
+Default Company Bank Account,Cont bancar al companiei implicite,
+From Lead,Din Pistă,
+Account Manager,Manager Conturi,
+Allow Sales Invoice Creation Without Sales Order,Permiteți crearea facturilor de vânzare fără comandă de vânzare,
+Allow Sales Invoice Creation Without Delivery Note,Permiteți crearea facturilor de vânzare fără notă de livrare,
+Default Price List,Lista de Prețuri Implicita,
+Primary Address and Contact Detail,Adresa principală și detaliile de contact,
+"Select, to make the customer searchable with these fields","Selectați, pentru a face ca clientul să poată fi căutat în aceste câmpuri",
+Customer Primary Contact,Contact primar client,
+"Reselect, if the chosen contact is edited after save",Resetați dacă contactul ales este editat după salvare,
+Customer Primary Address,Adresa primară a clientului,
+"Reselect, if the chosen address is edited after save",Resetați dacă adresa editată este editată după salvare,
+Primary Address,adresa primara,
+Mention if non-standard receivable account,Mentionati daca non-standard cont de primit,
+Credit Limit and Payment Terms,Limita de credit și termenii de plată,
+Additional information regarding the customer.,Informații suplimentare cu privire la client.,
+Sales Partner and Commission,Partener de vânzări și a Comisiei,
+Commission Rate,Rata de Comision,
+Sales Team Details,Detalii de vânzări Echipa,
+Customer POS id,ID POS client,
+Customer Credit Limit,Limita de creditare a clienților,
+Bypass Credit Limit Check at Sales Order,Treceți la verificarea limită de credit la Comandă de vânzări,
+Industry Type,Industrie Tip,
+MAT-INS-.YYYY.-,MAT-INS-.YYYY.-,
+Installation Date,Data de instalare,
+Installation Time,Timp de instalare,
+Installation Note Item,Instalare Notă Postul,
+Installed Qty,Instalat Cantitate,
+Lead Source,Sursa de plumb,
+Period Start Date,Data de începere a perioadei,
+Period End Date,Perioada de sfârșit a perioadei,
+Cashier,Casier,
+Difference,Diferență,
+Modes of Payment,Moduri de plată,
+Linked Invoices,Linked Factures,
+POS Closing Voucher Details,Detalii Voucher de închidere POS,
+Collected Amount,Suma colectată,
+Expected Amount,Suma așteptată,
+POS Closing Voucher Invoices,Facturi pentru voucherele de închidere de la POS,
+Quantity of Items,Cantitatea de articole,
+"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. \n\nThe package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".\n\nFor Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.\n\nNote: BOM = Bill of Materials","Grup agregat de articole ** ** în alt articol ** **. Acest lucru este util dacă gruparea de anumite elemente ** ** într-un pachet și să mențină un bilanț al ambalate ** ** Elemente și nu agregate ** Postul **. Pachetul ** Postul ** va avea &quot;Este Piesa&quot; ca &quot;No&quot; și &quot;Este punctul de vânzare&quot;, ca &quot;Da&quot;. De exemplu: dacă sunteți de vânzare Laptop-uri și Rucsacuri separat și au un preț special dacă clientul cumpără atât, atunci laptop + rucsac va fi un nou Bundle produs Postul. Notă: BOM = Bill de materiale",
+Parent Item,Părinte Articol,
+List items that form the package.,Listeaza articole care formează pachetul.,
+SAL-QTN-.YYYY.-,SAL-QTN-.YYYY.-,
+Quotation To,Ofertă Pentru a,
+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 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,
+Additional Discount and Coupon Code,Cod suplimentar de reducere și cupon,
+Referral Sales Partner,Partener de vânzări de recomandări,
+In Words will be visible once you save the Quotation.,În cuvinte va fi vizibil după ce salvați citat.,
+Term Details,Detalii pe termen,
+Quotation Item,Ofertă Articol,
+Against Doctype,Comparativ tipului documentului,
+Against Docname,Comparativ denumirii documentului,
+Additional Notes,Note Aditionale,
+SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-,
+Skip Delivery Note,Salt nota de livrare,
+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.,
+Track this Sales Order against any Project,Urmareste acest Ordin de vânzări față de orice proiect,
+Billing and Delivery Status,Facturare și stare livrare,
+Not Delivered,Nu Pronunțată,
+Fully Delivered,Livrat complet,
+Partly Delivered,Parțial livrate,
+Not Applicable,Nu se aplică,
+%  Delivered,% Livrat,
+% of materials delivered against this Sales Order,% de materiale livrate versus aceasta Comanda,
+% of materials billed against this Sales Order,% de materiale facturate versus această Comandă de Vânzări,
+Not Billed,Nu Taxat,
+Fully Billed,Complet Taxat,
+Partly Billed,Parțial Taxat,
+Ensure Delivery Based on Produced Serial No,Asigurați livrarea pe baza numărului de serie produs,
+Supplier delivers to Customer,Furnizor livrează la client,
+Delivery Warehouse,Depozit de livrare,
+Planned Quantity,Planificate Cantitate,
+For Production,Pentru Producție,
+Work Order Qty,Numărul comenzilor de lucru,
+Produced Quantity,Produs Cantitate,
+Used for Production Plan,Folosit pentru Planul de producție,
+Sales Partner Type,Tip de partener de vânzări,
+Contact No.,Nr. Persoana de Contact,
+Contribution (%),Contribuție (%),
+Contribution to Net Total,Contribuție la Total Net,
+Selling Settings,Setări Vânzare,
+Settings for Selling Module,Setări pentru vânzare Modulul,
+Customer Naming By,Numire Client de catre,
+Campaign Naming By,Campanie denumita de,
+Default Customer Group,Grup Clienți Implicit,
+Default Territory,Teritoriu Implicit,
+Close Opportunity After Days,Închide oportunitate După zile,
+Default Quotation Validity Days,Valabilitatea zilnică a cotațiilor,
+Sales Update Frequency,Frecventa actualizarii vanzarilor,
+Each Transaction,Fiecare tranzacție,
+SMS Center,SMS Center,
+Send To,Trimite la,
+All Contact,Toate contactele,
+All Customer Contact,Toate contactele clienților,
+All Supplier Contact,Toate contactele furnizorului,
+All Sales Partner Contact,Toate contactele partenerului de vânzări,
+All Lead (Open),Toate Pistele (Deschise),
+All Employee (Active),Toți angajații (activi),
+All Sales Person,Toate persoanele de vânzăril,
+Create Receiver List,Creare Lista Recipienti,
+Receiver List,Receptor Lista,
+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,
+Total Characters,Total de caractere,
+Total Message(s),Total mesaj(e),
+Authorization Control,Control de autorizare,
+Authorization Rule,Regulă de autorizare,
+Average Discount,Discount mediiu,
+Customerwise Discount,Reducere Client,
+Itemwise Discount,Reducere Articol-Avizat,
+Customer or Item,Client sau un element,
+Customer / Item Name,Client / Denumire articol,
+Authorized Value,Valoarea autorizată,
+Applicable To (Role),Aplicabil pentru (rol),
+Applicable To (Employee),Aplicabil pentru (angajat),
+Applicable To (User),Aplicabil pentru (utilizator),
+Applicable To (Designation),Aplicabil pentru (destinaţie),
+Approving Role (above authorized value),Aprobarea Rol (mai mare decât valoarea autorizată),
+Approving User  (above authorized value),Aprobarea utilizator (mai mare decât valoarea autorizată),
+Brand Defaults,Valorile implicite ale mărcii,
+Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Entitate Juridică / Filială cu o Diagramă de Conturi separată aparținând Organizației.,
+Change Abbreviation,Schimbă Abreviere,
+Parent Company,Compania mamă,
+Default Values,Valori implicite,
+Default Holiday List,Implicit Listă de vacanță,
+Default Selling Terms,Condiții de vânzare implicite,
+Default Buying Terms,Condiții de cumpărare implicite,
+Create Chart Of Accounts Based On,"Creează Diagramă de Conturi, Bazată pe",
+Standard Template,Format standard,
+Existing Company,Companie existentă,
+Chart Of Accounts Template,Diagramă de Șablon Conturi,
+Existing Company ,companie existentă,
+Date of Establishment,Data Înființării,
+Sales Settings,Setări de vânzări,
+Monthly Sales Target,Vânzări lunare,
+Sales Monthly History,Istoric Lunar de Vânzări,
+Transactions Annual History,Istoricul tranzacțiilor anuale,
+Total Monthly Sales,Vânzări totale lunare,
+Default Cash Account,Cont de Numerar Implicit,
+Default Receivable Account,Implicit cont de încasat,
+Round Off Cost Center,Rotunji cost Center,
+Discount Allowed Account,Cont permis de reducere,
+Discount Received Account,Reducerea contului primit,
+Exchange Gain / Loss Account,Cont Cheltuiala / Venit din diferente de curs valutar,
+Unrealized Exchange Gain/Loss Account,Contul de câștig / pierdere din contul nerealizat,
+Allow Account Creation Against Child Company,Permite crearea de cont împotriva companiei pentru copii,
+Default Payable Account,Implicit cont furnizori,
+Default Employee Advance Account,Implicit Cont Advance Advance Employee,
+Default Cost of Goods Sold Account,Cont Implicit Cost Bunuri Vândute,
+Default Income Account,Contul Venituri Implicit,
+Default Deferred Revenue Account,Implicit Contul cu venituri amânate,
+Default Deferred Expense Account,Implicit contul amânat de cheltuieli,
+Default Payroll Payable Account,Implicit Salarizare cont de plati,
+Default Expense Claim Payable Account,Cont Predefinit Solicitare Cheltuială Achitată,
+Stock Settings,Setări stoc,
+Enable Perpetual Inventory,Activați inventarul perpetuu,
+Default Inventory Account,Contul de inventar implicit,
+Stock Adjustment Account,Cont Ajustarea stoc,
+Fixed Asset Depreciation Settings,Setări de amortizare fixă Activ,
+Series for Asset Depreciation Entry (Journal Entry),Seria pentru intrarea în amortizarea activelor (intrare în jurnal),
+Gain/Loss Account on Asset Disposal,Cont câștig / Pierdere de eliminare a activelor,
+Asset Depreciation Cost Center,Centru de cost Amortizare Activ,
+Budget Detail,Detaliu buget,
+Exception Budget Approver Role,Rolul de abordare a bugetului de excepție,
+Company Info,Informaţii Companie,
+For reference only.,Numai Pentru referință.,
+Company Logo,Logoul companiei,
+Date of Incorporation,Data Încorporării,
+Date of Commencement,Data începerii,
+Phone No,Nu telefon,
+Company Description,Descrierea Companiei,
+Registration Details,Detalii de Înregistrare,
+Company registration numbers for your reference. Tax numbers etc.,Numerele de înregistrare companie pentru referință. Numerele fiscale etc,
+Delete Company Transactions,Ștergeți Tranzacții de Firma,
+Currency Exchange,Curs Valutar,
+Specify Exchange Rate to convert one currency into another,Precizați Rata de schimb a converti o monedă în alta,
+From Currency,Din moneda,
+To Currency,Pentru a valutar,
+For Buying,Pentru cumparare,
+For Selling,Pentru vânzări,
+Customer Group Name,Nume Group Client,
+Parent Customer Group,Părinte Grup Clienți,
+Only leaf nodes are allowed in transaction,Numai noduri frunze sunt permise în tranzacție,
+Mention if non-standard receivable account applicable,Menționa dacă non-standard de cont primit aplicabil,
+Credit Limits,Limitele de credit,
+Email Digest,Email Digest,
+Send regular summary reports via Email.,Trimite rapoarte de sinteză periodice prin e-mail.,
+Email Digest Settings,Setari Email Digest,
+How frequently?,Cât de frecvent?,
+Next email will be sent on:,Următorul email va fi trimis la:,
+Note: Email will not be sent to disabled users,Notă: Adresa de email nu va fi trimis la utilizatorii cu handicap,
+Profit & Loss,Pierderea profitului,
+New Income,noul venit,
+New Expenses,Cheltuieli noi,
+Annual Income,Venit anual,
+Annual Expenses,Cheltuielile anuale,
+Bank Balance,Banca Balance,
+Bank Credit Balance,Soldul creditului bancar,
+Receivables,Creanțe,
+Payables,Datorii,
+Sales Orders to Bill,Comenzi de vânzare către Bill,
+Purchase Orders to Bill,Achiziționați comenzi către Bill,
+New Sales Orders,Noi comenzi de vânzări,
+New Purchase Orders,Noi comenzi de aprovizionare,
+Sales Orders to Deliver,Comenzi de livrare pentru livrare,
+Purchase Orders to Receive,Comenzi de cumpărare pentru a primi,
+New Purchase Invoice,Factură de achiziție nouă,
+New Quotations,Noi Oferte,
+Open Quotations,Oferte deschise,
+Open Issues,Probleme deschise,
+Open Projects,Proiecte deschise,
+Purchase Orders Items Overdue,Elementele comenzilor de cumpărare sunt restante,
+Upcoming Calendar Events,Evenimente calendaristice viitoare,
+Open To Do,Deschis de făcut,
+Add Quote,Adaugă Citat,
+Global Defaults,Valori Implicite Globale,
+Default Company,Companie Implicită,
+Current Fiscal Year,An Fiscal Curent,
+Default Distance Unit,Unitatea de distanță standard,
+Hide Currency Symbol,Ascunde simbol moneda,
+Do not show any symbol like $ etc next to currencies.,Nu afisa nici un simbol de genul $ etc alături de valute.,
+"If disable, 'Rounded Total' field will not be visible in any transaction","Dacă este dezactivat, câmpul 'Total Rotunjit' nu va fi vizibil in nici o tranzacție",
+Disable In Words,Nu fi de acord în cuvinte,
+"If disable, 'In Words' field will not be visible in any transaction","În cazul în care dezactivați, &quot;în cuvinte&quot; câmp nu vor fi vizibile în orice tranzacție",
+Item Classification,Postul Clasificare,
+General Settings,Setări generale,
+Item Group Name,Denumire Grup Articol,
+Parent Item Group,Părinte Grupa de articole,
+Item Group Defaults,Setări implicite pentru grupul de articole,
+Item Tax,Taxa Articol,
+Check this if you want to show in website,Bifati dacă doriți să fie afisat în site,
+Show this slideshow at the top of the page,Arată această prezentare în partea de sus a paginii,
+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.",
+Set prefix for numbering series on your transactions,Set prefix pentru seria de numerotare pe tranzacțiile dvs.,
+Setup Series,Seria de configurare,
+Select Transaction,Selectați Transaction,
+Help HTML,Ajutor HTML,
+Series List for this Transaction,Lista de serie pentru această tranzacție,
+User must always select,Utilizatorul trebuie să selecteze întotdeauna,
+Check this if you want to force the user to select a series before saving. There will be no default if you check this.,"Bifati dacă doriți sa fortati utilizatorul să selecteze o serie înainte de a salva. Nu va exista nici o valoare implicita dacă se bifeaza aici.""",
+Update Series,Actualizare Series,
+Change the starting / current sequence number of an existing series.,Schimbați secventa de numar de inceput / curent a unei serii existente.,
+Prefix,Prefix,
+Current Value,Valoare curenta,
+This is the number of the last created transaction with this prefix,Acesta este numărul ultimei tranzacții create cu acest prefix,
+Update Series Number,Actualizare Serii Număr,
+Quotation Lost Reason,Ofertă pierdut rațiunea,
+A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Un distribuitor terță parte / dealer / agent comisionar / afiliat / re-vânzător care vinde produsele companiei pentru un comision.,
+Sales Partner Name,Numele Partner Sales,
+Partner Type,Tip partener,
+Address & Contacts,Adresă şi contacte,
+Address Desc,Adresă Desc,
+Contact Desc,Persoana de Contact Desc,
+Sales Partner Target,Vânzări Partner țintă,
+Targets,Obiective,
+Show In Website,Arata pe site-ul,
+Referral Code,Codul de recomandare,
+To Track inbound purchase,Pentru a urmări achiziția de intrare,
+Logo,Logo,
+Partner website,site-ul partenerului,
+All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,Toate tranzacțiile de vânzări pot fi etichetate comparativ mai multor **Persoane de vânzări** pentru ca dvs. sa puteţi configura și monitoriza obiective.,
+Name and Employee ID,Nume și ID angajat,
+Sales Person Name,Sales Person Nume,
+Parent Sales Person,Mamă Sales Person,
+Select company name first.,Selectați numele companiei în primul rând.,
+Sales Person Targets,Ținte Persoane Vânzări,
+Set targets Item Group-wise for this Sales Person.,Stabilească obiective Articol Grupa-înțelept pentru această persoană de vânzări.,
+Supplier Group Name,Numele grupului de furnizori,
+Parent Supplier Group,Grupul furnizorilor-mamă,
+Target Detail,Țintă Detaliu,
+Target Qty,Țintă Cantitate,
+Target  Amount,Suma țintă,
+Target Distribution,Țintă Distribuție,
+"Standard Terms and Conditions that can be added to Sales and Purchases.\n\nExamples:\n\n1. Validity of the offer.\n1. Payment Terms (In Advance, On Credit, part advance etc).\n1. What is extra (or payable by the Customer).\n1. Safety / usage warning.\n1. Warranty if any.\n1. Returns Policy.\n1. Terms of shipping, if applicable.\n1. Ways of addressing disputes, indemnity, liability, etc.\n1. Address and Contact of your Company.","Termeni și Condiții care pot fi adăugate la vânzările și achizițiile standard.\n\n Exemple: \n\n 1. Perioada de valabilitate a ofertei.\n 1. Conditii de plata (in avans, pe credit, parte în avans etc.).\n 1. Ce este în plus (sau de plătit de către Client).\n 1. Siguranța / avertizare utilizare.\n 1. Garantie dacă este cazul.\n 1. Politica de Returnare.\n 1. Condiții de transport maritim, dacă este cazul.\n 1. Modalitati de litigii de adresare, indemnizație, răspunderea, etc. \n 1. Adresa și de contact ale companiei.",
+Applicable Modules,Module aplicabile,
+Terms and Conditions Help,Termeni și Condiții Ajutor,
+Classification of Customers by region,Clasificarea clienți în funcție de regiune,
+Territory Name,Teritoriului Denumire,
+Parent Territory,Teritoriul părinte,
+Territory Manager,Teritoriu Director,
+For reference,Pentru referință,
+Territory Targets,Obiective Territory,
+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.",
+UOM Name,Numele UOM,
+Check this to disallow fractions. (for Nos),Bifati pentru a nu permite fracțiuni. (Pentru Nos),
+Website Item Group,Site-ul Grupa de articole,
+Cross Listing of Item in multiple groups,Crucea Listarea de punctul în mai multe grupuri,
+Default settings for Shopping Cart,Setările implicite pentru Cosul de cumparaturi,
+Enable Shopping Cart,Activați cosul de cumparaturi,
+Display Settings,Display Settings,
+Show Public Attachments,Afișați atașamentele publice,
+Show Price,Afișați prețul,
+Show Stock Availability,Afișați disponibilitatea stocului,
+Show Contact Us Button,Afișați butonul de contactare,
+Show Stock Quantity,Afișați cantitatea stocului,
+Show Apply Coupon Code,Afișați Aplicați codul de cupon,
+Allow items not in stock to be added to cart,Permiteți adăugarea în coș a articolelor care nu sunt în stoc,
+Prices will not be shown if Price List is not set,Prețurile nu vor fi afișate în cazul în care Prețul de listă nu este setat,
+Quotation Series,Ofertă Series,
+Checkout Settings,setările checkout pentru,
+Enable Checkout,activaţi Checkout,
+Payment Success Url,Plată de succes URL,
+After payment completion redirect user to selected page.,După finalizarea plății redirecționați utilizatorul la pagina selectată.,
+Batch Details,Detalii lot,
+Batch ID,ID-ul lotului,
+image,imagine,
+Parent Batch,Lotul părinte,
+Manufacturing Date,Data Fabricației,
+Batch Quantity,Cantitatea lotului,
+Batch UOM,Lot UOM,
+Source Document Type,Tipul documentului sursă,
+Source Document Name,Numele sursei de document,
+Batch Description,Descriere lot,
+Bin,Coş,
+Reserved Quantity,Cantitate rezervata,
+Actual Quantity,Cantitate Efectivă,
+Requested Quantity,Cantitate Solicitată,
+Reserved Qty for sub contract,Cantitate rezervată pentru subcontract,
+Moving Average Rate,Rata medie mobilă,
+FCFS Rate,Rata FCFS,
+Customs Tariff Number,Tariful vamal Număr,
+Tariff Number,Tarif Număr,
+Delivery To,De Livrare la,
+MAT-DN-.YYYY.-,MAT-DN-.YYYY.-,
+Is Return,Este de returnare,
+Issue Credit Note,Eliberați nota de credit,
+Return Against Delivery Note,Reveni Împotriva livrare Nota,
+Customer's Purchase Order No,Nr. Comanda de Aprovizionare Client,
+Billing Address Name,Numele din adresa de facturare,
+Required only for sample item.,Necesar numai pentru articolul de probă.,
+"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Dacă ați creat un model standard la taxele de vânzare și taxe Format, selectați una și faceți clic pe butonul de mai jos.",
+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 (Export) will be visible once you save the Delivery Note.,În cuvinte (de export) va fi vizibil după ce a salva de livrare Nota.,
+Transporter Info,Info Transporter,
+Driver Name,Numele șoferului,
+Track this Delivery Note against any Project,Urmareste acest Livrare Note împotriva oricărui proiect,
+Inter Company Reference,Referință între companii,
+Print Without Amount,Imprima Fără Suma,
+% Installed,% Instalat,
+% of materials delivered against this Delivery Note,% de materiale livrate versus acest Aviz de Expeditie,
+Installation Status,Starea de instalare,
+Excise Page Number,Numărul paginii accize,
+Instructions,Instrucţiuni,
+From Warehouse,Din Depozit,
+Against Sales Order,Contra comenzii de vânzări,
+Against Sales Order Item,Contra articolului comenzii de vânzări,
+Against Sales Invoice,Comparativ facturii de vânzări,
+Against Sales Invoice Item,Comparativ articolului facturii de vânzări,
+Available Batch Qty at From Warehouse,Disponibil lot Cantitate puțin din Warehouse,
+Available Qty at From Warehouse,Cantitate Disponibil la Depozitul,
+Delivery Settings,Setări de livrare,
+Dispatch Settings,Dispecerat Setări,
+Dispatch Notification Template,Șablonul de notificare pentru expediere,
+Dispatch Notification Attachment,Expedierea notificării atașament,
+Leave blank to use the standard Delivery Note format,Lăsați necompletat pentru a utiliza formatul standard de livrare,
+Send with Attachment,Trimiteți cu atașament,
+Delay between Delivery Stops,Întârziere între opririle de livrare,
+Delivery Stop,Livrare Stop,
+Lock,Lacăt,
+Visited,Vizitat,
+Order Information,Informații despre comandă,
+Contact Information,Informatii de contact,
+Email sent to,Email trimis catre,
+Dispatch Information,Informații despre expediere,
+Estimated Arrival,Sosirea estimată,
+MAT-DT-.YYYY.-,MAT-DT-.YYYY.-,
+Initial Email Notification Sent,Notificarea inițială de e-mail trimisă,
+Delivery Details,Detalii Livrare,
+Driver Email,E-mail șofer,
+Driver Address,Adresa șoferului,
+Total Estimated Distance,Distanța totală estimată,
+Distance UOM,Distanță UOM,
+Departure Time,Timp de plecare,
+Delivery Stops,Livrarea se oprește,
+Calculate Estimated Arrival Times,Calculează Timp de Sosire Estimat,
+Use Google Maps Direction API to calculate estimated arrival times,Utilizați Google Maps Direction API pentru a calcula orele de sosire estimate,
+Optimize Route,Optimizați ruta,
+Use Google Maps Direction API to optimize route,Utilizați Google Maps Direction API pentru a optimiza ruta,
+In Transit,În trecere,
+Fulfillment User,Utilizator de încredere,
+"A Product or a Service that is bought, sold or kept in stock.","Un produs sau un serviciu care este cumpărat, vândut sau păstrat în stoc.",
+STO-ITEM-.YYYY.-,STO-ELEMENT-.YYYY.-,
+Variant Of,Varianta de,
+"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Dacă elementul este o variantă de un alt element atunci descriere, imagine, de stabilire a prețurilor, impozite etc vor fi stabilite de șablon dacă nu se specifică în mod explicit",
+Is Item from Hub,Este element din Hub,
+Default Unit of Measure,Unitatea de Măsură Implicita,
+Maintain Stock,Articol Stocabil,
+Standard Selling Rate,Standard de vânzare Rata,
+Auto Create Assets on Purchase,Creați active automate la achiziție,
+Asset Naming Series,Serie de denumire a activelor,
+Over Delivery/Receipt Allowance (%),Indemnizație de livrare / primire (%),
+Barcodes,Coduri de bare,
+Shelf Life In Days,Perioada de valabilitate în zile,
+End of Life,Sfârsitul vieții,
+Default Material Request Type,Implicit Material Tip de solicitare,
+Valuation Method,Metoda de evaluare,
+FIFO,FIFO,
+Moving Average,Mutarea medie,
+Warranty Period (in days),Perioada de garanție (în zile),
+Auto re-order,Re-comandă automată,
+Reorder level based on Warehouse,Nivel pentru re-comanda bazat pe Magazie,
+Will also apply for variants unless overrridden,Se va aplica și pentru variantele cu excepția cazului în overrridden,
+Units of Measure,Unitati de masura,
+Will also apply for variants,"Va aplică, de asemenea pentru variante",
+Serial Nos and Batches,Numere și loturi seriale,
+Has Batch No,Are nr. de Lot,
+Automatically Create New Batch,Creare automată Lot nou,
+Batch Number Series,Seria numerelor serii,
+"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.","Exemplu: ABCD. #####. Dacă seria este setată și numărul lotului nu este menționat în tranzacții, atunci numărul lotului automat va fi creat pe baza acestei serii. Dacă doriți întotdeauna să menționați în mod explicit numărul lotului pentru acest articol, lăsați acest lucru necompletat. Notă: această setare va avea prioritate față de Prefixul Seriei de Nomenclatoare din Setările de stoc.",
+Has Expiry Date,Are data de expirare,
+Retain Sample,Păstrați eșantionul,
+Max Sample Quantity,Cantitate maximă de probă,
+Maximum sample quantity that can be retained,Cantitatea maximă de mostră care poate fi reținută,
+Has Serial No,Are nr. de serie,
+Serial Number Series,Serial Number Series,
+"Example: ABCD.#####\nIf series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Exemplu:. ABCD ##### \n Dacă 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ă întotdeauna doriți să se menționeze explicit Serial nr de acest articol. părăsi acest gol.",
+Variants,Variante,
+Has Variants,Are variante,
+"If this item has variants, then it cannot be selected in sales orders etc.","Dacă acest element are variante, atunci nu poate fi selectat în comenzile de vânzări, etc.",
+Variant Based On,Varianta Bazat pe,
+Item Attribute,Postul Atribut,
+"Sales, Purchase, Accounting Defaults","Vânzări, Cumpărare, Definiții de contabilitate",
+Item Defaults,Elemente prestabilite,
+"Purchase, Replenishment Details","Detalii de achiziție, reconstituire",
+Is Purchase Item,Este de cumparare Articol,
+Default Purchase Unit of Measure,Unitatea de măsură prestabilită a măsurii,
+Minimum Order Qty,Comanda minima Cantitate,
+Minimum quantity should be as per Stock UOM,Cantitatea minimă ar trebui să fie conform UOM-ului de stoc,
+Average time taken by the supplier to deliver,Timpul mediu luate de către furnizor de a livra,
+Is Customer Provided Item,Este articol furnizat de client,
+Delivered by Supplier (Drop Ship),Livrate de Furnizor (Drop navelor),
+Supplier Items,Furnizor Articole,
+Foreign Trade Details,Detalii Comerț Exterior,
+Country of Origin,Tara de origine,
+Sales Details,Detalii Vânzări,
+Default Sales Unit of Measure,Unitatea de vânzare standard de măsură,
+Is Sales Item,Este produs de vânzări,
+Max Discount (%),Max Discount (%),
+No of Months,Numărul de luni,
+Customer Items,Articole clientului,
+Inspection Criteria,Criteriile de inspecție,
+Inspection Required before Purchase,Necesar de inspecție înainte de achiziționare,
+Inspection Required before Delivery,Necesar de inspecție înainte de livrare,
+Default BOM,FDM Implicit,
+Supply Raw Materials for Purchase,Materii prime de alimentare pentru cumparare,
+If subcontracted to a vendor,Dacă subcontractat la un furnizor,
+Customer Code,Cod client,
+Default Item Manufacturer,Producător de articole implicit,
+Default Manufacturer Part No,Cod producător implicit,
+Show in Website (Variant),Afișați în site-ul (Variant),
+Items with higher weightage will be shown higher,Articole cu weightage mare va fi afișat mai mare,
+Show a slideshow at the top of the page,Arata un slideshow din partea de sus a paginii,
+Website Image,Imagine Web,
+Website Warehouse,Website Depozit,
+"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.",
+Website Item Groups,Site-ul Articol Grupuri,
+List this Item in multiple groups on the website.,Listeaza acest articol in grupuri multiple de pe site-ul.\,
+Copy From Item Group,Copiere din Grupul de Articole,
+Website Content,Conținutul site-ului web,
+You can use any valid Bootstrap 4 markup in this field. It will be shown on your Item Page.,Puteți utiliza orice marcaj Bootstrap 4 valabil în acest câmp. Acesta va fi afișat pe pagina dvs. de articole.,
+Total Projected Qty,Cantitate totală prevăzută,
+Hub Publishing Details,Detalii privind publicarea Hubului,
+Publish in Hub,Publica in Hub,
+Publish Item to hub.erpnext.com,Publica Postul de hub.erpnext.com,
+Hub Category to Publish,Categorie Hub pentru publicare,
+Hub Warehouse,Hub Depozit,
+"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.","Publicați &quot;În stoc&quot; sau &quot;Nu este în stoc&quot; pe Hub, pe baza stocurilor disponibile în acest depozit.",
+Synced With Hub,Sincronizat cu Hub,
+Item Alternative,Alternativă la element,
+Alternative Item Code,Codul elementului alternativ,
+Two-way,Două căi,
+Alternative Item Name,Numele elementului alternativ,
+Attribute Name,Denumire atribut,
+Numeric Values,Valori numerice,
+From Range,Din gama,
+Increment,Creștere,
+To Range,La gama,
+Item Attribute Values,Valori Postul Atribut,
+Item Attribute Value,Postul caracteristicii Valoarea,
+Attribute Value,Valoare Atribut,
+Abbreviation,Abreviere,
+"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","Acest lucru va fi adăugat la Codul punctul de varianta. De exemplu, în cazul în care abrevierea este ""SM"", iar codul produs face ""T-SHIRT"", codul punctul de varianta va fi ""T-SHIRT-SM""",
+Item Barcode,Element de coduri de bare,
+Barcode Type,Tip de cod de bare,
+EAN,EAN,
+UPC-A,UPC-A,
+Item Customer Detail,Detaliu Articol Client,
+"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",
+Ref Code,Cod de Ref,
+Item Default,Element Implicit,
+Purchase Defaults,Valori implicite pentru achiziții,
+Default Buying Cost Center,Centru de Cost Cumparare Implicit,
+Default Supplier,Furnizor Implicit,
+Default Expense Account,Cont de Cheltuieli Implicit,
+Sales Defaults,Setări prestabilite pentru vânzări,
+Default Selling Cost Center,Centru de Cost Vanzare Implicit,
+Item Manufacturer,Postul Producator,
+Item Price,Preț Articol,
+Packing Unit,Unitate de ambalare,
+Quantity  that must be bought or sold per UOM,Cantitatea care trebuie cumpărată sau vândută pe UOM,
+Item Quality Inspection Parameter,Parametru Inspecție de Calitate Articol,
+Acceptance Criteria,Criteriile de receptie,
+Item Reorder,Reordonare Articol,
+Check in (group),Check-in (grup),
+Request for,Cerere pentru,
+Re-order Level,Nivelul de re-comandă,
+Re-order Qty,Re-comanda Cantitate,
+Item Supplier,Furnizor Articol,
+Item Variant,Postul Varianta,
+Item Variant Attribute,Varianta element Atribut,
+Do not update variants on save,Nu actualizați variantele de salvare,
+Fields will be copied over only at time of creation.,Câmpurile vor fi copiate numai în momentul creării.,
+Allow Rename Attribute Value,Permiteți redenumirea valorii atributului,
+Rename Attribute Value in Item Attribute.,Redenumiți valoarea atributului în atributul de element.,
+Copy Fields to Variant,Copiați câmpurile în varianta,
+Item Website Specification,Specificație Site Articol,
+Table for Item that will be shown in Web Site,Tabelul pentru postul care va fi afișat în site-ul,
+Landed Cost Item,Cost Final Articol,
+Receipt Document Type,Primire Tip de document,
+Receipt Document,Documentul de primire,
+Applicable Charges,Taxe aplicabile,
+Purchase Receipt Item,Primirea de cumpărare Postul,
+Landed Cost Purchase Receipt,Chitanta de Cumparare aferent Costului Final,
+Landed Cost Taxes and Charges,Impozite cost debarcate și Taxe,
+Landed Cost Voucher,Voucher Cost Landed,
+MAT-LCV-.YYYY.-,MAT-LCV-.YYYY.-,
+Purchase Receipts,Încasări de cumparare,
+Purchase Receipt Items,Primirea de cumpărare Articole,
+Get Items From Purchase Receipts,Obține elemente din achiziție Încasări,
+Distribute Charges Based On,Împărțiți taxelor pe baza,
+Landed Cost Help,Costul Ajutor Landed,
+Manufacturers used in Items,Producători utilizați în Articole,
+Limited to 12 characters,Limitată la 12 de caractere,
+MAT-MR-.YYYY.-,MAT-MR-.YYYY.-,
+Partially Ordered,Parțial comandat,
+Transferred,transferat,
+% Ordered,% Comandat,
+Terms and Conditions Content,Termeni și condiții de conținut,
+Quantity and Warehouse,Cantitatea și Warehouse,
+Lead Time Date,Data Timp Conducere,
+Min Order Qty,Min Ordine Cantitate,
+Packed Item,Articol ambalate,
+To Warehouse (Optional),La Depozit (opțional),
+Actual Batch Quantity,Cantitatea actuală de lot,
+Prevdoc DocType,Prevdoc Doctype,
+Parent Detail docname,Părinte Detaliu docname,
+"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generarea de ambalare slip pentru pachetele de a fi livrate. Folosit pentru a notifica numărul pachet, conținutul pachetului și greutatea sa.",
+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),
+MAT-PAC-.YYYY.-,MAT-PAC-.YYYY.-,
+From Package No.,Din Pachetul Nr.,
+Identification of the package for the delivery (for print),Identificarea pachetului pentru livrare (pentru imprimare),
+To Package No.,La pachetul Nr,
+If more than one package of the same type (for print),În cazul în care mai mult de un pachet de același tip (pentru imprimare),
+Package Weight Details,Pachetul Greutate Detalii,
+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),
+Net Weight UOM,Greutate neta UOM,
+Gross Weight,Greutate brută,
+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)",
+Gross Weight UOM,Greutate Brută UOM,
+Packing Slip Item,Bonul Articol,
+DN Detail,Detaliu DN,
+STO-PICK-.YYYY.-,STO-PICK-.YYYY.-,
+Material Transfer for Manufacture,Transfer de materii pentru fabricarea,
+Qty of raw materials will be decided based on the qty of the Finished Goods Item,Cantitatea de materii prime va fi decisă pe baza cantității articolului de produse finite,
+Parent Warehouse,Depozit Părinte,
+Items under this warehouse will be suggested,Articolele din acest depozit vor fi sugerate,
+Get Item Locations,Obțineți locații de articole,
+Item Locations,Locații articol,
+Pick List Item,Alegeți articolul din listă,
+Picked Qty,Cules Qty,
+Price List Master,Lista de preturi Masterat,
+Price List Name,Lista de prețuri Nume,
+Price Not UOM Dependent,Pretul nu este dependent de UOM,
+Applicable for Countries,Aplicabile pentru țările,
+Price List Country,Lista de preturi Țară,
+MAT-PRE-.YYYY.-,MAT-PRE-.YYYY.-,
+Supplier Delivery Note,Nota de livrare a furnizorului,
+Time at which materials were received,Timp în care s-au primit materiale,
+Return Against Purchase Receipt,Reveni cu confirmare de primire cumparare,
+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,
+Sets 'Accepted Warehouse' in each row of the items table.,Setează „Depozit acceptat” în fiecare rând al tabelului cu articole.,
+Sets 'Rejected Warehouse' in each row of the items table.,Setează „Depozit respins” în fiecare rând al tabelului cu articole.,
+Raw Materials Consumed,Materii prime consumate,
+Get Current Stock,Obține stocul curent,
+Consumed Items,Articole consumate,
+Add / Edit Taxes and Charges,Adaugaţi / editaţi taxe și cheltuieli,
+Auto Repeat Detail,Repeatarea detaliilor automate,
+Transporter Details,Detalii Transporter,
+Vehicle Number,Numărul de vehicule,
+Vehicle Date,Vehicul Data,
+Received and Accepted,Primit și Acceptat,
+Accepted Quantity,Cantitatea Acceptata,
+Rejected Quantity,Cantitate Respinsă,
+Accepted Qty as per Stock UOM,Cantitate acceptată conform stocului UOM,
+Sample Quantity,Cantitate de probă,
+Rate and Amount,Rata și volumul,
+MAT-QA-.YYYY.-,MAT-QA-.YYYY.-,
+Report Date,Data raportului,
+Inspection Type,Inspecție Tip,
+Item Serial No,Nr. de Serie Articol,
+Sample Size,Eșantionul de dimensiune,
+Inspected By,Inspectat de,
+Readings,Lecturi,
+Quality Inspection Reading,Inspecție de calitate Reading,
+Reading 1,Lectura 1,
+Reading 2,Lectura 2,
+Reading 3,Lectura 3,
+Reading 4,Lectura 4,
+Reading 5,Lectura 5,
+Reading 6,Lectura 6,
+Reading 7,Lectură 7,
+Reading 8,Lectură 8,
+Reading 9,Lectură 9,
+Reading 10,Lectura 10,
+Quality Inspection Template Name,Numele de șablon de inspecție a calității,
+Quick Stock Balance,Soldul rapid al stocurilor,
+Available Quantity,Cantitate Disponibilă,
+Distinct unit of an Item,Unitate distinctă de Postul,
+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,
+Purchase / Manufacture Details,Detalii de cumpărare / Fabricarea,
+Creation Document Type,Tip de document creație,
+Creation Document No,Creare Document Nr.,
+Creation Date,Data creării,
+Creation Time,Timp de creare,
+Asset Details,Detalii privind activul,
+Asset Status,Starea activelor,
+Delivery Document Type,Tipul documentului de Livrare,
+Delivery Document No,Nr. de document de Livrare,
+Delivery Time,Timp de Livrare,
+Invoice Details,Detaliile facturii,
+Warranty / AMC Details,Garanție / AMC Detalii,
+Warranty Expiry Date,Garanție Data expirării,
+AMC Expiry Date,Dată expirare AMC,
+Under Warranty,În garanție,
+Out of Warranty,Ieșit din garanție,
+Under AMC,Sub AMC,
+Out of AMC,Din AMC,
+Warranty Period (Days),Perioada de garanție (zile),
+Serial No Details,Serial Nu Detalii,
+MAT-STE-.YYYY.-,MAT-STE-.YYYY.-,
+Stock Entry Type,Tip intrare stoc,
+Stock Entry (Outward GIT),Intrare pe stoc (GIT exterior),
+Material Consumption for Manufacture,Consumul de materiale pentru fabricare,
+Repack,Reambalați,
+Send to Subcontractor,Trimiteți către subcontractant,
+Delivery Note No,Nr. Nota de Livrare,
+Sales Invoice No,Nr. Factură de Vânzări,
+Purchase Receipt No,Primirea de cumpărare Nu,
+Inspection Required,Inspecție obligatorii,
+From BOM,De la BOM,
+For Quantity,Pentru Cantitate,
+As per Stock UOM,Ca şi pentru stoc UOM,
+Including items for sub assemblies,Inclusiv articole pentru subansambluri,
+Default Source Warehouse,Depozit Sursa Implicit,
+Source Warehouse Address,Adresă Depozit Sursă,
+Default Target Warehouse,Depozit Tinta Implicit,
+Target Warehouse Address,Adresa de destinație a depozitului,
+Update Rate and Availability,Actualizarea Rata și disponibilitatea,
+Total Incoming Value,Valoarea totală a sosi,
+Total Outgoing Value,Valoarea totală de ieșire,
+Total Value Difference (Out - In),Diferența Valoarea totală (Out - In),
+Additional Costs,Costuri suplimentare,
+Total Additional Costs,Costuri totale suplimentare,
+Customer or Supplier Details,Client sau furnizor Detalii,
+Per Transferred,Per transferat,
+Stock Entry Detail,Stoc de intrare Detaliu,
+Basic Rate (as per Stock UOM),Rata de bază (conform Stock UOM),
+Basic Amount,Suma de bază,
+Additional Cost,Cost aditional,
+Serial No / Batch,Serial No / lot,
+BOM No. for a Finished Good Item,Nr. BOM pentru un articol tip produs finalizat,
+Material Request used to make this Stock Entry,Cerere de material utilizat pentru a face acest stoc de intrare,
+Subcontracted Item,Subcontractat element,
+Against Stock Entry,Împotriva intrării pe stoc,
+Stock Entry Child,Copil de intrare în stoc,
+PO Supplied Item,PO Articol furnizat,
+Reference Purchase Receipt,Recepție de achiziție de achiziție,
+Stock Ledger Entry,Registru Contabil Intrări,
+Outgoing Rate,Rata de ieșire,
+Actual Qty After Transaction,Cant. efectivă după tranzacție,
+Stock Value Difference,Valoarea Stock Diferența,
+Stock Queue (FIFO),Stoc Queue (FIFO),
+Is Cancelled,Este anulat,
+Stock Reconciliation,Stoc Reconciliere,
+This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,Acest instrument vă ajută să actualizați sau stabili cantitatea și evaluarea stocului in sistem. Acesta este de obicei folosit pentru a sincroniza valorile de sistem și ceea ce există de fapt în depozite tale.,
+MAT-RECO-.YYYY.-,MAT-RECO-.YYYY.-,
+Reconciliation JSON,Reconciliere JSON,
+Stock Reconciliation Item,Stock reconciliere Articol,
+Before reconciliation,Premergător reconcilierii,
+Current Serial No,Serial curent nr,
+Current Valuation Rate,Rata de evaluare curentă,
+Current Amount,Suma curentă,
+Quantity Difference,cantitate diferenţă,
+Amount Difference,suma diferenţă,
+Item Naming By,Denumire Articol Prin,
+Default Item Group,Group Articol Implicit,
+Default Stock UOM,Stoc UOM Implicit,
+Sample Retention Warehouse,Exemplu de reținere depozit,
+Default Valuation Method,Metoda de Evaluare Implicită,
+Show Barcode Field,Afișează coduri de bare Câmp,
+Convert Item Description to Clean HTML,Conversia elementului de articol pentru a curăța codul HTML,
+Allow Negative Stock,Permiteţi stoc negativ,
+Automatically Set Serial Nos based on FIFO,Setat automat Serial nr bazat pe FIFO,
+Auto Material Request,Cerere automată de material,
+Inter Warehouse Transfer Settings,Setări de transfer între depozite,
+Freeze Stock Entries,Blocheaza Intrarile in Stoc,
+Stock Frozen Upto,Stoc Frozen Până la,
+Batch Identification,Identificarea lotului,
+Use Naming Series,Utilizați seria de numire,
+Naming Series Prefix,Denumirea prefixului seriei,
+UOM Category,Categoria UOM,
+UOM Conversion Detail,Detaliu UOM de conversie,
+Variant Field,Varianta câmpului,
+A logical Warehouse against which stock entries are made.,Un depozit logic față de care se efectuează înregistrări de stoc.,
+Warehouse Detail,Detaliu Depozit,
+Warehouse Name,Denumire Depozit,
+Warehouse Contact Info,Date de contact depozit,
+PIN,PIN,
+ISS-.YYYY.-,ISS-.YYYY.-,
+Raised By (Email),Ridicat de (E-mail),
+Issue Type,Tipul problemei,
+Issue Split From,Problemă Split From,
+Service Level,Nivel de servicii,
+Response By,Răspuns de,
+Response By Variance,Răspuns după variație,
+Ongoing,În curs de desfășurare,
+Resolution By,Rezolvare de,
+Resolution By Variance,Rezolutie prin variatie,
+Service Level Agreement Creation,Crearea contractului de nivel de serviciu,
+First Responded On,Primul Răspuns la,
+Resolution Details,Detalii Rezoluție,
+Opening Date,Data deschiderii,
+Opening Time,Timp de deschidere,
+Resolution Date,Dată Rezoluție,
+Via Customer Portal,Prin portalul de clienți,
+Support Team,Echipa de Suport,
+Issue Priority,Prioritate de emisiune,
+Service Day,Ziua serviciului,
+Workday,Zi de lucru,
+Default Priority,Prioritate implicită,
+Priorities,priorităţi,
+Support Hours,Ore de sprijin,
+Support and Resolution,Suport și rezoluție,
+Default Service Level Agreement,Acordul implicit privind nivelul serviciilor,
+Entity,Entitate,
+Agreement Details,Detalii despre acord,
+Response and Resolution Time,Timp de răspuns și rezolvare,
+Service Level Priority,Prioritate la nivel de serviciu,
+Resolution Time,Timp de rezoluție,
+Support Search Source,Sprijiniți sursa de căutare,
+Source Type,Tipul sursei,
+Query Route String,Query String Rout,
+Search Term Param Name,Termenul de căutare Param Name,
+Response Options,Opțiuni de Răspuns,
+Response Result Key Path,Răspuns Rezultat Cale cheie,
+Post Route String,Postați șirul de rută,
+Post Route Key List,Afișați lista cheilor de rutare,
+Post Title Key,Titlul mesajului cheie,
+Post Description Key,Post Descriere cheie,
+Link Options,Link Opțiuni,
+Source DocType,Sursa DocType,
+Result Title Field,Câmp rezultat titlu,
+Result Preview Field,Câmp de examinare a rezultatelor,
+Result Route Field,Câmp de rutare rezultat,
+Service Level Agreements,Acorduri privind nivelul serviciilor,
+Track Service Level Agreement,Urmăriți acordul privind nivelul serviciilor,
+Allow Resetting Service Level Agreement,Permiteți resetarea contractului de nivel de serviciu,
+Close Issue After Days,Închide Problemă După Zile,
+Auto close Issue after 7 days,Închidere automată Problemă după 7 zile,
+Support Portal,Portal de suport,
+Get Started Sections,Începeți secțiunile,
+Show Latest Forum Posts,Arată ultimele postări pe forum,
+Forum Posts,Mesaje pe forum,
+Forum URL,Adresa URL a forumului,
+Get Latest Query,Obțineți ultima interogare,
+Response Key List,Listă cu chei de răspuns,
+Post Route Key,Introduceți cheia de rutare,
+Search APIs,API-uri de căutare,
+SER-WRN-.YYYY.-,SER-WRN-.YYYY.-,
+Issue Date,Data emiterii,
+Item and Warranty Details,Postul și garanție Detalii,
+Warranty / AMC Status,Garanție / AMC Starea,
+Resolved By,Rezolvat prin,
+Service Address,Adresa serviciu,
+If different than customer address,Dacă diferă de adresa client,
+Raised By,Ridicat De,
+From Company,De la Compania,
+Rename Tool,Instrument Redenumire,
+Utilities,Utilitați,
+Type of document to rename.,Tip de document pentru a redenumi.,
+File to Rename,Fișier de Redenumiți,
+"Attach .csv file with two columns, one for the old name and one for the new name","Atașați fișier .csv cu două coloane, una pentru denumirea veche și una pentru denumirea nouă",
+Rename Log,Redenumi Conectare,
+SMS Log,SMS Conectare,
+Sender Name,Sender Name,
+Sent On,A trimis pe,
+No of Requested SMS,Nu de SMS solicitat,
+Requested Numbers,Numere solicitate,
+No of Sent SMS,Nu de SMS-uri trimise,
+Sent To,Trimis La,
+Absent Student Report,Raport elev absent,
+Assessment Plan Status,Starea planului de evaluare,
+Asset Depreciation Ledger,Registru Amortizatre Active,
+Asset Depreciations and Balances,Amortizari si Balante Active,
+Available Stock for Packing Items,Stoc disponibil pentru articole destinate împachetării,
+Bank Clearance Summary,Sumar aprobare bancă,
+Bank Remittance,Transferul bancar,
+Batch Item Expiry Status,Lot Articol Stare de expirare,
+Batch-Wise Balance History,Istoricul balanţei principale aferente lotului,
+BOM Explorer,BOM Explorer,
+BOM Search,BOM Căutare,
+BOM Stock Calculated,BOM Stocul calculat,
+BOM Variance Report,BOM Raport de variație,
+Campaign Efficiency,Eficiența campaniei,
+Cash Flow,Fluxul de numerar,
+Completed Work Orders,Ordine de lucru finalizate,
+To Produce,Pentru a produce,
+Produced,Produs,
+Consolidated Financial Statement,Situație financiară consolidată,
+Course wise Assessment Report,Raport de evaluare în curs,
+Customer Acquisition and Loyalty,Achiziționare și Loialitate Client,
+Customer Credit Balance,Balanța Clienți credit,
+Customer Ledger Summary,Rezumatul evidenței clienților,
+Customer-wise Item Price,Prețul articolului pentru clienți,
+Customers Without Any Sales Transactions,Clienții fără tranzacții de vânzare,
+Daily Timesheet Summary,Rezumat Pontaj Zilnic,
+Daily Work Summary Replies,Rezumat zilnic de lucrări,
+DATEV,DATEV,
+Delayed Item Report,Raportul întârziat al articolului,
+Delayed Order Report,Raportul de comandă întârziat,
+Delivered Items To Be Billed,Produse Livrate Pentru a fi Facturate,
+Delivery Note Trends,Tendințe Nota de Livrare,
+Electronic Invoice Register,Registrul electronic al facturilor,
+Employee Advance Summary,Sumarul avansului pentru angajați,
+Employee Billing Summary,Rezumatul facturării angajaților,
+Employee Birthday,Zi de naștere angajat,
+Employee Information,Informații angajat,
+Employee Leave Balance,Bilant Concediu Angajat,
+Employee Leave Balance Summary,Rezumatul soldului concediilor angajaților,
+Employees working on a holiday,Numar de angajati care lucreaza in vacanta,
+Eway Bill,Eway Bill,
+Expiring Memberships,Expirarea calității de membru,
+Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptabile [FEC],
+Final Assessment Grades,Evaluări finale,
+Fixed Asset Register,Registrul activelor fixe,
+Gross and Net Profit Report,Raport de profit brut și net,
+GST Itemised Purchase Register,GST Registrul achiziționărilor detaliate,
+GST Itemised Sales Register,Registrul de vânzări detaliat GST,
+GST Purchase Register,Registrul achizițiilor GST,
+GST Sales Register,Registrul vânzărilor GST,
+GSTR-1,GSTR-1,
+GSTR-2,GSTR-2,
+Hotel Room Occupancy,Hotel Ocuparea camerei,
+HSN-wise-summary of outward supplies,Rezumatul HSN pentru rezervele exterioare,
+Inactive Customers,Clienții inactive,
+Inactive Sales Items,Articole de vânzare inactive,
+IRS 1099,IRS 1099,
+Issued Items Against Work Order,Articole emise împotriva comenzii de lucru,
+Projected Quantity as Source,Cantitatea ca sursă proiectată,
+Item Balance (Simple),Balanța postului (simplă),
+Item Price Stock,Preț Stoc Articol,
+Item Prices,Preturi Articol,
+Item Shortage Report,Raport Articole Lipsa,
+Item Variant Details,Element Variant Details,
+Item-wise Price List Rate,Rata Lista de Pret Articol-Avizat,
+Item-wise Purchase History,Istoric Achizitii Articol-Avizat,
+Item-wise Purchase Register,Registru Achizitii Articol-Avizat,
+Item-wise Sales History,Istoric Vanzari Articol-Avizat,
+Item-wise Sales Register,Registru Vanzari Articol-Avizat,
+Items To Be Requested,Articole care vor fi solicitate,
+Reserved,Rezervat,
+Itemwise Recommended Reorder Level,Nivel de Reordonare Recomandat al Articolului-Awesome,
+Lead Details,Detalii Pistă,
+Lead Owner Efficiency,Lead Efficiency Owner,
+Loan Repayment and Closure,Rambursarea împrumutului și închiderea,
+Loan Security Status,Starea de securitate a împrumutului,
+Lost Opportunity,Oportunitate pierdută,
+Maintenance Schedules,Program de Mentenanta,
+Material Requests for which Supplier Quotations are not created,Cererile de materiale pentru care nu sunt create Cotațiile Furnizor,
+Monthly Attendance Sheet,Lunar foaia de prezență,
+Open Work Orders,Deschideți comenzile de lucru,
+Qty to Deliver,Cantitate pentru a oferi,
+Patient Appointment Analytics,Analiza programării pacientului,
+Payment Period Based On Invoice Date,Perioada de plată Bazat pe Data facturii,
+Pending SO Items For Purchase Request,Până la SO articole pentru cerere de oferta,
+Procurement Tracker,Urmărirea achizițiilor,
+Product Bundle Balance,Soldul pachetului de produse,
+Production Analytics,Google Analytics de producție,
+Profit and Loss Statement,Profit și pierdere,
+Profitability Analysis,Analiza profitabilității,
+Project Billing Summary,Rezumatul facturării proiectului,
+Project wise Stock Tracking,Urmărirea proiectului în funcție de stoc,
+Project wise Stock Tracking ,Proiect înțelept Tracking Stock,
+Prospects Engaged But Not Converted,Perspective implicate dar nu convertite,
+Purchase Analytics,Analytics de cumpărare,
+Purchase Invoice Trends,Cumpărare Tendințe factură,
+Qty to Receive,Cantitate de a primi,
+Received Qty Amount,Suma de cantitate primită,
+Billed Qty,Qty facturat,
+Purchase Order Trends,Comandă de aprovizionare Tendințe,
+Purchase Receipt Trends,Tendințe Primirea de cumpărare,
+Purchase Register,Cumpărare Inregistrare,
+Quotation Trends,Cotație Tendințe,
+Received Items To Be Billed,Articole primite Pentru a fi facturat,
+Qty to Order,Cantitate pentru comandă,
+Requested Items To Be Transferred,Articole solicitate de transferat,
+Qty to Transfer,Cantitate de a transfera,
+Salary Register,Salariu Înregistrare,
+Sales Analytics,Analitice de vânzare,
+Sales Invoice Trends,Vânzări Tendințe factură,
+Sales Order Trends,Vânzări Ordine Tendințe,
+Sales Partner Commission Summary,Rezumatul Comisiei partenere de vânzări,
+Sales Partner Target Variance based on Item Group,Varianța de țintă a partenerilor de vânzări bazată pe grupul de articole,
+Sales Partner Transaction Summary,Rezumat tranzacție partener vânzări,
+Sales Partners Commission,Comision Agenţi Vânzări,
+Invoiced Amount (Exclusive Tax),Suma facturată (taxă exclusivă),
+Average Commission Rate,Rată de comision medie,
+Sales Payment Summary,Rezumatul plăților pentru vânzări,
+Sales Person Commission Summary,Persoana de vânzări Rezumat al Comisiei,
+Sales Person Target Variance Based On Item Group,Vânzarea persoanei de vânzare Varianța bazată pe grupul de articole,
+Sales Person-wise Transaction Summary,Persoana de vânzări-înțelept Rezumat Transaction,
+Sales Register,Vânzări Inregistrare,
+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,
+Stock Ageing,Stoc Îmbătrânirea,
+Stock and Account Value Comparison,Comparația valorilor stocurilor și conturilor,
+Stock Projected Qty,Stoc proiectată Cantitate,
+Student and Guardian Contact Details,Student și Guardian Detalii de contact,
+Student Batch-Wise Attendance,Lot-înțelept elev Participarea,
+Student Fee Collection,Taxa de student Colectia,
+Student Monthly Attendance Sheet,Elev foaia de prezență lunară,
+Subcontracted Item To Be Received,Articol subcontractat care trebuie primit,
+Subcontracted Raw Materials To Be Transferred,Materii prime subcontractate care trebuie transferate,
+Supplier Ledger Summary,Rezumat evidență furnizor,
+Supplier-Wise Sales Analytics,Furnizor înțelept Vânzări Analytics,
+Support Hour Distribution,Distribuția orelor de distribuție,
+TDS Computation Summary,Rezumatul TDS de calcul,
+TDS Payable Monthly,TDS plătibil lunar,
+Territory Target Variance Based On Item Group,Varianța țintă de teritoriu pe baza grupului de articole,
+Territory-wise Sales,Vânzări înțelese teritoriul,
+Total Stock Summary,Rezumatul Total al Stocului,
+Trial Balance,Balanta,
+Trial Balance (Simple),Soldul de încercare (simplu),
+Trial Balance for Party,Trial Balance pentru Party,
+Unpaid Expense Claim,Solicitare Cheltuială Neachitată,
+Warehouse wise Item Balance Age and Value,Warehouse wise Item Balance Age și Value,
+Work Order Stock Report,Raport de stoc pentru comanda de lucru,
+Work Orders in Progress,Ordine de lucru în curs,
+Validation Error,eroare de validatie,
+Automatically Process Deferred Accounting Entry,Procesați automat intrarea contabilă amânată,
+Bank Clearance,Clearance bancar,
+Bank Clearance Detail,Detaliu de lichidare bancară,
+Update Cost Center Name / Number,Actualizați numele / numărul centrului de costuri,
+Journal Entry Template,Șablon de intrare în jurnal,
+Template Title,Titlul șablonului,
+Journal Entry Type,Tipul intrării în jurnal,
+Journal Entry Template Account,Cont șablon de intrare în jurnal,
+Process Deferred Accounting,Procesul de contabilitate amânată,
+Manual entry cannot be created! Disable automatic entry for deferred accounting in accounts settings and try again,Intrarea manuală nu poate fi creată! Dezactivați intrarea automată pentru contabilitatea amânată în setările conturilor și încercați din nou,
+End date cannot be before start date,Data de încheiere nu poate fi înainte de data de începere,
+Total Counts Targeted,Numărul total vizat,
+Total Counts Completed,Numărul total finalizat,
+Counts Targeted: {0},Număruri vizate: {0},
+Payment Account is mandatory,Contul de plată este obligatoriu,
+"If checked, the full amount will be deducted from taxable income before calculating income tax without any declaration or proof submission.","Dacă este bifat, suma totală va fi dedusă din venitul impozabil înainte de calcularea impozitului pe venit fără nicio declarație sau depunere de dovadă.",
+Disbursement Details,Detalii despre debursare,
+Material Request Warehouse,Depozit cerere material,
+Select warehouse for material requests,Selectați depozitul pentru solicitări de materiale,
+Transfer Materials For Warehouse {0},Transfer de materiale pentru depozit {0},
+Production Plan Material Request Warehouse,Plan de producție Cerere de materiale Depozit,
+Sets 'Source Warehouse' in each row of the items table.,Setează „Depozit sursă” în fiecare rând al tabelului cu articole.,
+Sets 'Target Warehouse' in each row of the items table.,Setează „Depozit țintă” în fiecare rând al tabelului cu articole.,
+Show Cancelled Entries,Afișați intrările anulate,
+Backdated Stock Entry,Intrare de stoc actualizată,
+Row #{}: Currency of {} - {} doesn't matches company currency.,Rândul # {}: moneda {} - {} nu se potrivește cu moneda companiei.,
+{} Assets created for {},{} Active create pentru {},
+{0} Number {1} is already used in {2} {3},{0} Numărul {1} este deja utilizat în {2} {3},
+Update Bank Clearance Dates,Actualizați datele de compensare bancară,
+Healthcare Practitioner: ,Practician medical:,
+Lab Test Conducted: ,Test de laborator efectuat:,
+Lab Test Event: ,Eveniment de test de laborator:,
+Lab Test Result: ,Rezultatul testului de laborator:,
+Clinical Procedure conducted: ,Procedura clinică efectuată:,
+Therapy Session Charges: {0},Taxe pentru sesiunea de terapie: {0},
+Therapy: ,Terapie:,
+Therapy Plan: ,Planul de terapie:,
+Total Counts Targeted: ,Număruri totale vizate:,
+Total Counts Completed: ,Numărul total finalizat:,
+Andaman and Nicobar Islands,Insulele Andaman și Nicobar,
+Andhra Pradesh,Andhra Pradesh,
+Arunachal Pradesh,Arunachal Pradesh,
+Assam,Assam,
+Bihar,Bihar,
+Chandigarh,Chandigarh,
+Chhattisgarh,Chhattisgarh,
+Dadra and Nagar Haveli,Dadra și Nagar Haveli,
+Daman and Diu,Daman și Diu,
+Delhi,Delhi,
+Goa,Goa,
+Gujarat,Gujarat,
+Haryana,Haryana,
+Himachal Pradesh,Himachal Pradesh,
+Jammu and Kashmir,Jammu și Kashmir,
+Jharkhand,Jharkhand,
+Karnataka,Karnataka,
+Kerala,Kerala,
+Lakshadweep Islands,Insulele Lakshadweep,
+Madhya Pradesh,Madhya Pradesh,
+Maharashtra,Maharashtra,
+Manipur,Manipur,
+Meghalaya,Meghalaya,
+Mizoram,Mizoram,
+Nagaland,Nagaland,
+Odisha,Odisha,
+Other Territory,Alt teritoriu,
+Pondicherry,Pondicherry,
+Punjab,Punjab,
+Rajasthan,Rajasthan,
+Sikkim,Sikkim,
+Tamil Nadu,Tamil Nadu,
+Telangana,Telangana,
+Tripura,Tripura,
+Uttar Pradesh,Uttar Pradesh,
+Uttarakhand,Uttarakhand,
+West Bengal,Bengalul de Vest,
+Is Mandatory,Este obligatoriu,
+Published on,publicat pe,
+Service Received But Not Billed,"Serviciu primit, dar nu facturat",
+Deferred Accounting Settings,Setări de contabilitate amânate,
+Book Deferred Entries Based On,Rezervați intrări amânate pe baza,
+Days,Zile,
+Months,Luni,
+Book Deferred Entries Via Journal Entry,Rezervați intrări amânate prin intrarea în jurnal,
+Submit Journal Entries,Trimiteți intrări în jurnal,
+If this is unchecked Journal Entries will be saved in a Draft state and will have to be submitted manually,"Dacă aceasta nu este bifată, jurnalele vor fi salvate într-o stare de schiță și vor trebui trimise manual",
+Enable Distributed Cost Center,Activați Centrul de cost distribuit,
+Distributed Cost Center,Centrul de cost distribuit,
+Dunning,Poftă,
+DUNN-.MM.-.YY.-,DUNN-.MM .-. YY.-,
+Overdue Days,Zile restante,
+Dunning Type,Tipul Dunning,
+Dunning Fee,Taxă Dunning,
+Dunning Amount,Suma Dunning,
+Resolved,S-a rezolvat,
+Unresolved,Nerezolvat,
+Printing Setting,Setare imprimare,
+Body Text,Corpul textului,
+Closing Text,Text de închidere,
+Resolve,Rezolva,
+Dunning Letter Text,Text scrisoare Dunning,
+Is Default Language,Este limba implicită,
+Letter or Email Body Text,Text pentru corp scrisoare sau e-mail,
+Letter or Email Closing Text,Text de închidere prin scrisoare sau e-mail,
+Body and Closing Text Help,Ajutor pentru corp și text de închidere,
+Overdue Interval,Interval întârziat,
+Dunning Letter,Scrisoare Dunning,
+"This section allows the user to set the Body and Closing text of the Dunning Letter for the Dunning Type based on language, which can be used in Print.","Această secțiune permite utilizatorului să seteze corpul și textul de închidere al Scrisorii Dunning pentru tipul Dunning în funcție de limbă, care poate fi utilizat în Tipărire.",
+Reference Detail No,Nr. Detalii referință,
+Custom Remarks,Observații personalizate,
+Please select a Company first.,Vă rugăm să selectați mai întâi o companie.,
+"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice, Journal Entry or Dunning","Rândul # {0}: tipul documentului de referință trebuie să fie unul dintre Comanda de vânzări, Factura de vânzări, Înregistrarea jurnalului sau Sarcina",
+POS Closing Entry,Intrare de închidere POS,
+POS Opening Entry,Intrare de deschidere POS,
+POS Transactions,Tranzacții POS,
+POS Closing Entry Detail,Detaliu intrare închidere POS,
+Opening Amount,Suma de deschidere,
+Closing Amount,Suma de închidere,
+POS Closing Entry Taxes,Taxe de intrare POS închidere,
+POS Invoice,Factură POS,
+ACC-PSINV-.YYYY.-,ACC-PSINV-.YYYY.-,
+Consolidated Sales Invoice,Factură de vânzări consolidată,
+Return Against POS Invoice,Reveniți împotriva facturii POS,
+Consolidated,Consolidat,
+POS Invoice Item,Articol factură POS,
+POS Invoice Merge Log,Jurnal de îmbinare a facturilor POS,
+POS Invoices,Facturi POS,
+Consolidated Credit Note,Nota de credit consolidată,
+POS Invoice Reference,Referință factură POS,
+Set Posting Date,Setați data de înregistrare,
+Opening Balance Details,Detalii sold deschidere,
+POS Opening Entry Detail,Detaliu intrare deschidere POS,
+POS Payment Method,Metoda de plată POS,
+Payment Methods,Metode de plata,
+Process Statement Of Accounts,Procesul de situație a conturilor,
+General Ledger Filters,Filtre majore,
+Customers,Clienți,
+Select Customers By,Selectați Clienți după,
+Fetch Customers,Aduceți clienții,
+Send To Primary Contact,Trimiteți la contactul principal,
+Print Preferences,Preferințe de imprimare,
+Include Ageing Summary,Includeți rezumatul îmbătrânirii,
+Enable Auto Email,Activați e-mailul automat,
+Filter Duration (Months),Durata filtrului (luni),
+CC To,CC To,
+Help Text,Text de ajutor,
+Emails Queued,E-mailuri la coadă,
+Process Statement Of Accounts Customer,Procesul extras de cont client,
+Billing Email,E-mail de facturare,
+Primary Contact Email,E-mail de contact principal,
+PSOA Cost Center,Centrul de cost PSOA,
+PSOA Project,Proiectul PSOA,
+ACC-PINV-RET-.YYYY.-,ACC-PINV-RET-.YYYY.-,
+Supplier GSTIN,Furnizor GSTIN,
+Place of Supply,Locul aprovizionării,
+Select Billing Address,Selectați Adresa de facturare,
+GST Details,Detalii GST,
+GST Category,Categoria GST,
+Registered Regular,Înregistrat regulat,
+Registered Composition,Compoziție înregistrată,
+Unregistered,Neînregistrat,
+SEZ,SEZ,
+Overseas,De peste mări,
+UIN Holders,Titulari UIN,
+With Payment of Tax,Cu plata impozitului,
+Without Payment of Tax,Fără plata impozitului,
+Invoice Copy,Copie factură,
+Original for Recipient,Original pentru Destinatar,
+Duplicate for Transporter,Duplicat pentru Transporter,
+Duplicate for Supplier,Duplicat pentru furnizor,
+Triplicate for Supplier,Triplicat pentru furnizor,
+Reverse Charge,Taxare inversă,
+Y,Da,
+N,N,
+E-commerce GSTIN,Comerț electronic GSTIN,
+Reason For Issuing document,Motivul eliberării documentului,
+01-Sales Return,01-Returnarea vânzărilor,
+02-Post Sale Discount,02-Reducere după vânzare,
+03-Deficiency in services,03-Deficiența serviciilor,
+04-Correction in Invoice,04-Corecție în factură,
+05-Change in POS,05-Modificare POS,
+06-Finalization of Provisional assessment,06-Finalizarea evaluării provizorii,
+07-Others,07-Altele,
+Eligibility For ITC,Eligibilitate pentru ITC,
+Input Service Distributor,Distribuitor de servicii de intrare,
+Import Of Service,Importul serviciului,
+Import Of Capital Goods,Importul de bunuri de capital,
+Ineligible,Neeligibil,
+All Other ITC,Toate celelalte ITC,
+Availed ITC Integrated Tax,Taxă integrată ITC disponibilă,
+Availed ITC Central Tax,Taxă centrală ITC disponibilă,
+Availed ITC State/UT Tax,Impozit ITC de stat / UT disponibil,
+Availed ITC Cess,Cess ITC disponibil,
+Is Nil Rated or Exempted,Este evaluat zero sau scutit,
+Is Non GST,Nu este GST,
+ACC-SINV-RET-.YYYY.-,ACC-SINV-RET-.YYYY.-,
+E-Way Bill No.,E-Way Bill nr.,
+Is Consolidated,Este consolidat,
+Billing Address GSTIN,Adresa de facturare GSTIN,
+Customer GSTIN,Client GSTIN,
+GST Transporter ID,ID GST Transporter,
+Distance (in km),Distanță (în km),
+Road,drum,
+Air,Aer,
+Rail,Feroviar,
+Ship,Navă,
+GST Vehicle Type,Tipul vehiculului GST,
+Over Dimensional Cargo (ODC),Marfă supradimensională (ODC),
+Consumer,Consumator,
+Deemed Export,Export estimat,
+Port Code,Cod port,
+ Shipping Bill Number,Numărul facturii de expediere,
+Shipping Bill Date,Data facturii de expediere,
+Subscription End Date,Data de încheiere a abonamentului,
+Follow Calendar Months,Urmăriți lunile calendaristice,
+If this is checked subsequent new invoices will be created on calendar  month and quarter start dates irrespective of current invoice start date,"Dacă se verifică acest lucru, vor fi create noi facturi ulterioare în lunile calendaristice și în datele de începere a trimestrului, indiferent de data curentă de începere a facturii",
+Generate New Invoices Past Due Date,Generați facturi noi la scadență,
+New invoices will be generated as per schedule even if current invoices are unpaid or past due date,"Facturile noi vor fi generate conform programului, chiar dacă facturile curente sunt neplătite sau sunt scadente",
+Document Type ,Tipul documentului,
+Subscription Price Based On,Prețul abonamentului pe baza,
+Fixed Rate,Rata fixa,
+Based On Price List,Pe baza listei de prețuri,
+Monthly Rate,Rată lunară,
+Cancel Subscription After Grace Period,Anulați abonamentul după perioada de grație,
+Source State,Statul sursă,
+Is Inter State,Este statul Inter,
+Purchase Details,Detalii achiziție,
+Depreciation Posting Date,Data înregistrării amortizării,
+"By default, the Supplier Name is set as per the Supplier Name entered. If you want Suppliers to be named by a  ","În mod implicit, numele furnizorului este setat conform numelui furnizorului introdus. Dacă doriți ca Furnizorii să fie numiți de către un",
+ choose the 'Naming Series' option.,alegeți opțiunea „Denumirea seriei”.,
+Configure the default Price List when creating a new Purchase transaction. Item prices will be fetched from this Price List.,Configurați lista de prețuri implicită atunci când creați o nouă tranzacție de cumpărare. Prețurile articolelor vor fi preluate din această listă de prețuri.,
+"If this option is configured 'Yes', ERPNext will prevent you from creating a Purchase Invoice or Receipt without creating a Purchase Order first. This configuration can be overridden for a particular supplier by enabling the 'Allow Purchase Invoice Creation Without Purchase Order' checkbox in the Supplier master.","Dacă această opțiune este configurată „Da”, ERPNext vă va împiedica să creați o factură de achiziție sau o chitanță fără a crea mai întâi o comandă de cumpărare. Această configurație poate fi anulată pentru un anumit furnizor activând caseta de selectare „Permite crearea facturii de cumpărare fără comandă de cumpărare” din masterul furnizorului.",
+"If this option is configured 'Yes', ERPNext will prevent you from creating a Purchase Invoice without creating a Purchase Receipt first. This configuration can be overridden for a particular supplier by enabling the 'Allow Purchase Invoice Creation Without Purchase Receipt' checkbox in the Supplier master.","Dacă această opțiune este configurată „Da”, ERPNext vă va împiedica să creați o factură de cumpărare fără a crea mai întâi o chitanță de cumpărare. Această configurație poate fi suprascrisă pentru un anumit furnizor activând caseta de selectare „Permite crearea facturii de cumpărare fără chitanță de cumpărare” din masterul furnizorului.",
+Quantity & Stock,Cantitate și stoc,
+Call Details,Detalii apel,
+Authorised By,Autorizat de,
+Signee (Company),Destinatar (companie),
+Signed By (Company),Semnat de (Companie),
+First Response Time,Timpul primului răspuns,
+Request For Quotation,Cerere de ofertă,
+Opportunity Lost Reason Detail,Detaliu despre motivul pierdut al oportunității,
+Access Token Secret,Accesează Token Secret,
+Add to Topics,Adăugați la subiecte,
+...Adding Article to Topics,... Adăugarea articolului la subiecte,
+Add Article to Topics,Adăugați un articol la subiecte,
+This article is already added to the existing topics,Acest articol este deja adăugat la subiectele existente,
+Add to Programs,Adăugați la Programe,
+Programs,Programe,
+...Adding Course to Programs,... Adăugarea cursului la programe,
+Add Course to Programs,Adăugați cursul la programe,
+This course is already added to the existing programs,Acest curs este deja adăugat la programele existente,
+Learning Management System Settings,Setările sistemului de management al învățării,
+Enable Learning Management System,Activați sistemul de gestionare a învățării,
+Learning Management System Title,Titlul sistemului de management al învățării,
+...Adding Quiz to Topics,... Adăugarea testului la subiecte,
+Add Quiz to Topics,Adăugați test la subiecte,
+This quiz is already added to the existing topics,Acest test este deja adăugat la subiectele existente,
+Enable Admission Application,Activați cererea de admitere,
+EDU-ATT-.YYYY.-,EDU-ATT-.YYYY.-,
+Marking attendance,Marcarea prezenței,
+Add Guardians to Email Group,Adăugați Gardieni în grupul de e-mail,
+Attendance Based On,Prezență bazată pe,
+Check this to mark the student as present in case the student is not attending the institute to participate or represent the institute in any event.\n\n,Bifați acest lucru pentru a marca studentul ca prezent în cazul în care studentul nu participă la institut pentru a participa sau pentru a reprezenta institutul în orice caz.,
+Add to Courses,Adăugați la Cursuri,
+...Adding Topic to Courses,... Adăugarea subiectului la cursuri,
+Add Topic to Courses,Adăugați subiect la cursuri,
+This topic is already added to the existing courses,Acest subiect este deja adăugat la cursurile existente,
+"If Shopify does not have a customer in the order, then while syncing the orders, the system will consider the default customer for the order","Dacă Shopify nu are un client în comandă, atunci în timp ce sincronizează comenzile, sistemul va lua în considerare clientul implicit pentru comandă",
+The accounts are set by the system automatically but do confirm these defaults,"Conturile sunt setate automat de sistem, dar confirmă aceste valori implicite",
+Default Round Off Account,Cont implicit rotunjit,
+Failed Import Log,Jurnal de importare eșuat,
+Fixed Error Log,S-a remediat jurnalul de erori,
+Company {0} already exists. Continuing will overwrite the Company and Chart of Accounts,Compania {0} există deja. Continuarea va suprascrie compania și planul de conturi,
+Meta Data,Meta Date,
+Unresolve,Nerezolvat,
+Create Document,Creați document,
+Mark as unresolved,Marcați ca nerezolvat,
+TaxJar Settings,Setări TaxJar,
+Sandbox Mode,Mod Sandbox,
+Enable Tax Calculation,Activați calculul impozitului,
+Create TaxJar Transaction,Creați tranzacția TaxJar,
+Credentials,Acreditări,
+Live API Key,Cheie API live,
+Sandbox API Key,Cheia API Sandbox,
+Configuration,Configurare,
+Tax Account Head,Șef cont fiscal,
+Shipping Account Head,Șef cont de expediere,
+Practitioner Name,Numele practicianului,
+Enter a name for the Clinical Procedure Template,Introduceți un nume pentru șablonul de procedură clinică,
+Set the Item Code which will be used for billing the Clinical Procedure.,Setați codul articolului care va fi utilizat pentru facturarea procedurii clinice.,
+Select an Item Group for the Clinical Procedure Item.,Selectați un grup de articole pentru articolul de procedură clinică.,
+Clinical Procedure Rate,Rata procedurii clinice,
+Check this if the Clinical Procedure is billable and also set the rate.,"Verificați acest lucru dacă procedura clinică este facturabilă și, de asemenea, setați rata.",
+Check this if the Clinical Procedure utilises consumables. Click ,Verificați acest lucru dacă procedura clinică utilizează consumabile. Clic,
+ to know more,să afle mai multe,
+"You can also set the Medical Department for the template. After saving the document, an Item will automatically be created for billing this Clinical Procedure. You can then use this template while creating Clinical Procedures for Patients. Templates save you from filling up redundant data every single time. You can also create templates for other operations like Lab Tests, Therapy Sessions, etc.","De asemenea, puteți seta Departamentul medical pentru șablon. După salvarea documentului, un articol va fi creat automat pentru facturarea acestei proceduri clinice. Puteți utiliza apoi acest șablon în timp ce creați proceduri clinice pentru pacienți. Șabloanele vă scutesc de la completarea datelor redundante de fiecare dată. De asemenea, puteți crea șabloane pentru alte operații precum teste de laborator, sesiuni de terapie etc.",
+Descriptive Test Result,Rezultatul testului descriptiv,
+Allow Blank,Permiteți golul,
+Descriptive Test Template,Șablon de test descriptiv,
+"If you want to track Payroll and other HRMS operations for a Practitoner, create an Employee and link it here.","Dacă doriți să urmăriți salarizarea și alte operațiuni HRMS pentru un practician, creați un angajat și conectați-l aici.",
+Set the Practitioner Schedule you just created. This will be used while booking appointments.,Setați programul de practicanți pe care tocmai l-ați creat. Aceasta va fi utilizată la rezervarea programărilor.,
+Create a service item for Out Patient Consulting.,Creați un element de serviciu pentru consultarea externă a pacienților.,
+"If this Healthcare Practitioner works for the In-Patient Department, create a service item for Inpatient Visits.","Dacă acest profesionist din domeniul sănătății lucrează pentru departamentul internat, creați un articol de servicii pentru vizitele internate.",
+Set the Out Patient Consulting Charge for this Practitioner.,Stabiliți taxa pentru consultarea pacientului pentru acest practicant.,
+"If this Healthcare Practitioner also works for the In-Patient Department, set the inpatient visit charge for this Practitioner.","În cazul în care acest profesionist din domeniul sănătății lucrează și pentru secția de internare, stabiliți taxa de vizitare pentru acest practician.",
+"If checked, a customer will be created for every Patient. Patient Invoices will be created against this Customer. You can also select existing Customer while creating a Patient. This field is checked by default.","Dacă este bifat, va fi creat un client pentru fiecare pacient. Facturile pacientului vor fi create împotriva acestui client. De asemenea, puteți selecta clientul existent în timp ce creați un pacient. Acest câmp este bifat implicit.",
+Collect Registration Fee,Încasează taxa de înregistrare,
+"If your Healthcare facility bills registrations of Patients, you can check this and set the Registration Fee in the field below. Checking this will create new Patients with a Disabled status by default and will only be enabled after invoicing the Registration Fee.","Dacă unitatea medicală facturează înregistrările pacienților, puteți verifica acest lucru și puteți stabili taxa de înregistrare în câmpul de mai jos. Verificând acest lucru se vor crea noi pacienți cu starea Dezactivat în mod implicit și vor fi activate numai după facturarea Taxei de înregistrare.",
+Checking this will automatically create a Sales Invoice whenever an appointment is booked for a Patient.,Verificarea acestui lucru va crea automat o factură de vânzare ori de câte ori este rezervată o întâlnire pentru un pacient.,
+Healthcare Service Items,Produse pentru servicii medicale,
+"You can create a service item for Inpatient Visit Charge and set it here. Similarly, you can set up other Healthcare Service Items for billing in this section. Click ","Puteți crea un articol de serviciu pentru taxa de vizită internată și setați-l aici. În mod similar, puteți configura alte elemente de servicii medicale pentru facturare în această secțiune. Clic",
+Set up default Accounts for the Healthcare Facility,Configurați conturi implicite pentru unitatea medicală,
+"If you wish to override default accounts settings and configure the Income and Receivable accounts for Healthcare, you can do so here.","Dacă doriți să înlocuiți setările implicite ale conturilor și să configurați conturile de venituri și creanțe pentru asistență medicală, puteți face acest lucru aici.",
+Out Patient SMS alerts,Alerte SMS pentru pacienți,
+"If you want to send SMS alert on Patient Registration, you can enable this option. Similary, you can set up Out Patient SMS alerts for other functionalities in this section. Click ","Dacă doriți să trimiteți alertă SMS la înregistrarea pacientului, puteți activa această opțiune. În mod similar, puteți configura alerte SMS pentru pacient pentru alte funcționalități în această secțiune. Clic",
+Admission Order Details,Detalii comandă de admitere,
+Admission Ordered For,Admiterea comandată pentru,
+Expected Length of Stay,Durata de ședere preconizată,
+Admission Service Unit Type,Tipul unității de servicii de admitere,
+Healthcare Practitioner (Primary),Practician medical (primar),
+Healthcare Practitioner (Secondary),Practician medical (secundar),
+Admission Instruction,Instrucțiuni de admitere,
+Chief Complaint,Plângere șefă,
+Medications,Medicamente,
+Investigations,Investigații,
+Discharge Detials,Detalii de descărcare,
+Discharge Ordered Date,Data comandării descărcării,
+Discharge Instructions,Instrucțiuni de descărcare de gestiune,
+Follow Up Date,Data de urmărire,
+Discharge Notes,Note de descărcare de gestiune,
+Processing Inpatient Discharge,Procesarea externării internate,
+Processing Patient Admission,Procesarea admiterii pacientului,
+Check-in time cannot be greater than the current time,Ora de check-in nu poate fi mai mare decât ora curentă,
+Process Transfer,Transfer de proces,
+HLC-LAB-.YYYY.-,HLC-LAB-.YYYY.-,
+Expected Result Date,Data rezultatului așteptat,
+Expected Result Time,Timp de rezultat așteptat,
+Printed on,Tipărit pe,
+Requesting Practitioner,Practician solicitant,
+Requesting Department,Departamentul solicitant,
+Employee (Lab Technician),Angajat (tehnician de laborator),
+Lab Technician Name,Numele tehnicianului de laborator,
+Lab Technician Designation,Desemnarea tehnicianului de laborator,
+Compound Test Result,Rezultatul testului compus,
+Organism Test Result,Rezultatul testului de organism,
+Sensitivity Test Result,Rezultatul testului de sensibilitate,
+Worksheet Print,Imprimare foaie de lucru,
+Worksheet Instructions,Instrucțiuni pentru foaia de lucru,
+Result Legend Print,Imprimare legendă rezultat,
+Print Position,Poziția de imprimare,
+Bottom,Partea de jos,
+Top,Top,
+Both,Ambii,
+Result Legend,Legenda rezultatului,
+Lab Tests,Teste de laborator,
+No Lab Tests found for the Patient {0},Nu s-au găsit teste de laborator pentru pacient {0},
+"Did not send SMS, missing patient mobile number or message content.","Nu am trimis SMS-uri, lipsă numărul de mobil al pacientului sau conținutul mesajului.",
+No Lab Tests created,Nu au fost create teste de laborator,
+Creating Lab Tests...,Se creează teste de laborator ...,
+Lab Test Group Template,Șablon de grup de test de laborator,
+Add New Line,Adăugați o linie nouă,
+Secondary UOM,UOM secundar,
+"<b>Single</b>: Results which require only a single input.\n<br>\n<b>Compound</b>: Results which require multiple event inputs.\n<br>\n<b>Descriptive</b>: Tests which have multiple result components with manual result entry.\n<br>\n<b>Grouped</b>: Test templates which are a group of other test templates.\n<br>\n<b>No Result</b>: Tests with no results, can be ordered and billed but no Lab Test will be created. e.g.. Sub Tests for Grouped results","<b>Single</b> : Rezultate care necesită o singură intrare.<br> <b>Compus</b> : Rezultate care necesită mai multe intrări de evenimente.<br> <b>Descriptiv</b> : teste care au mai multe componente ale rezultatelor cu introducerea manuală a rezultatelor.<br> <b>Grupate</b> : șabloane de testare care sunt un grup de alte șabloane de testare.<br> <b>Niciun rezultat</b> : testele fără rezultate, pot fi comandate și facturate, dar nu va fi creat niciun test de laborator. de exemplu. Subteste pentru rezultate grupate",
+"If unchecked, the item will not be available in Sales Invoices for billing but can be used in group test creation. ","Dacă nu este bifat, articolul nu va fi disponibil în facturile de vânzare pentru facturare, dar poate fi utilizat la crearea testului de grup.",
+Description ,Descriere,
+Descriptive Test,Test descriptiv,
+Group Tests,Teste de grup,
+Instructions to be printed on the worksheet,Instrucțiuni care trebuie tipărite pe foaia de lucru,
+"Information to help easily interpret the test report, will be printed as part of the Lab Test result.",Informațiile care vor ajuta la interpretarea cu ușurință a raportului de testare vor fi tipărite ca parte a rezultatului testului de laborator.,
+Normal Test Result,Rezultat normal al testului,
+Secondary UOM Result,Rezultatul UOM secundar,
+Italic,Cursiv,
+Underline,Subliniați,
+Organism,Organism,
+Organism Test Item,Element de testare a organismului,
+Colony Population,Populația coloniei,
+Colony UOM,Colonia UOM,
+Tobacco Consumption (Past),Consumul de tutun (trecut),
+Tobacco Consumption (Present),Consumul de tutun (Prezent),
+Alcohol Consumption (Past),Consumul de alcool (trecut),
+Alcohol Consumption (Present),Consumul de alcool (prezent),
+Billing Item,Articol de facturare,
+Medical Codes,Coduri medicale,
+Clinical Procedures,Proceduri clinice,
+Order Admission,Admiterea comenzii,
+Scheduling Patient Admission,Programarea admiterii pacientului,
+Order Discharge,Descărcare comandă,
+Sample Details,Detalii mostre,
+Collected On,Colectat pe,
+No. of prints,Nr. De amprente,
+Number of prints required for labelling the samples,Numărul de tipăriri necesare pentru etichetarea probelor,
+HLC-VTS-.YYYY.-,HLC-VTS-.YYYY.-,
+In Time,La timp,
+Out Time,Timp liber,
+Payroll Cost Center,Centru de salarizare,
+Approvers,Aprobatori,
+The first Approver in the list will be set as the default Approver.,Primul aprobator din listă va fi setat ca aprobator implicit.,
+Shift Request Approver,Aprobarea cererii de schimbare,
+PAN Number,Număr PAN,
+Provident Fund Account,Contul Fondului Provident,
+MICR Code,Cod MICR,
+Repay unclaimed amount from salary,Rambursați suma nepreluată din salariu,
+Deduction from salary,Deducerea din salariu,
+Expired Leaves,Frunze expirate,
+Reference No,Nr. De referință,
+Haircut percentage is the percentage difference between market value of the Loan Security and the value ascribed to that Loan Security when used as collateral for that loan.,Procentul de tunsoare este diferența procentuală dintre valoarea de piață a titlului de împrumut și valoarea atribuită respectivului titlu de împrumut atunci când este utilizat ca garanție pentru împrumutul respectiv.,
+Loan To Value Ratio expresses the ratio of the loan amount to the value of the security pledged. A loan security shortfall will be triggered if this falls below the specified value for any loan ,Raportul împrumut la valoare exprimă raportul dintre suma împrumutului și valoarea garanției gajate. O deficiență a garanției împrumutului va fi declanșată dacă aceasta scade sub valoarea specificată pentru orice împrumut,
+If this is not checked the loan by default will be considered as a Demand Loan,"Dacă acest lucru nu este verificat, împrumutul implicit va fi considerat un împrumut la cerere",
+This account is used for booking loan repayments from the borrower and also disbursing loans to the borrower,"Acest cont este utilizat pentru rezervarea rambursărilor de împrumut de la împrumutat și, de asemenea, pentru a plăti împrumuturi către împrumutat",
+This account is capital account which is used to allocate capital for loan disbursal account ,Acest cont este un cont de capital care este utilizat pentru alocarea de capital pentru contul de debursare a împrumutului,
+This account will be used for booking loan interest accruals,Acest cont va fi utilizat pentru rezervarea dobânzilor la dobândă de împrumut,
+This account will be used for booking penalties levied due to delayed repayments,Acest cont va fi utilizat pentru rezervarea penalităților percepute din cauza rambursărilor întârziate,
+Variant BOM,Varianta DOM,
+Template Item,Articol șablon,
+Select template item,Selectați elementul șablon,
+Select variant item code for the template item {0},Selectați varianta codului articolului pentru elementul șablon {0},
+Downtime Entry,Intrare în timp de inactivitate,
+DT-,DT-,
+Workstation / Machine,Stație de lucru / Mașină,
+Operator,Operator,
+In Mins,În minele,
+Downtime Reason,Motivul opririi,
+Stop Reason,Stop Reason,
+Excessive machine set up time,Timp excesiv de configurare a mașinii,
+Unplanned machine maintenance,Întreținerea neplanificată a mașinii,
+On-machine press checks,Verificări de presă la mașină,
+Machine operator errors,Erori operator operator,
+Machine malfunction,Funcționarea defectuoasă a mașinii,
+Electricity down,Electricitate scăzută,
+Operation Row Number,Număr rând operațiune,
+Operation {0} added multiple times in the work order {1},Operația {0} adăugată de mai multe ori în ordinea de lucru {1},
+"If ticked, multiple materials can be used for a single Work Order. This is useful if one or more time consuming products are being manufactured.","Dacă este bifat, mai multe materiale pot fi utilizate pentru o singură comandă de lucru. Acest lucru este util dacă sunt fabricate unul sau mai multe produse consumatoare de timp.",
+Backflush Raw Materials,Materii prime Backflush,
+"The Stock Entry of type 'Manufacture' is known as backflush. Raw materials being consumed to manufacture finished goods is known as backflushing. <br><br> When creating Manufacture Entry, raw-material items are backflushed based on BOM of production item. If you want raw-material items to be backflushed based on Material Transfer entry made against that Work Order instead, then you can set it under this field.","Intrarea în stoc a tipului „Fabricare” este cunoscută sub numele de backflush. Materiile prime consumate pentru fabricarea produselor finite sunt cunoscute sub numele de backflushing.<br><br> La crearea intrării în fabricație, articolele din materie primă sunt revocate pe baza BOM a articolului de producție. Dacă doriți ca elementele din materie primă să fie revocate în funcție de intrarea de transfer de materiale efectuată împotriva respectivei comenzi de lucru, atunci o puteți seta în acest câmp.",
+Work In Progress Warehouse,Depozit Work In Progress,
+This Warehouse will be auto-updated in the Work In Progress Warehouse field of Work Orders.,Acest depozit va fi actualizat automat în câmpul Depozit de lucru în curs al comenzilor de lucru.,
+Finished Goods Warehouse,Depozit de produse finite,
+This Warehouse will be auto-updated in the Target Warehouse field of Work Order.,Acest depozit va fi actualizat automat în câmpul Depozit țintă din Ordinul de lucru.,
+"If ticked, the BOM cost will be automatically updated based on Valuation Rate / Price List Rate / last purchase rate of raw materials.","Dacă este bifat, costul BOM va fi actualizat automat în funcție de rata de evaluare / rata de listă de prețuri / ultima rată de achiziție a materiilor prime.",
+Source Warehouses (Optional),Depozite sursă (opțional),
+"System will pickup the materials from the selected warehouses. If not specified, system will create material request for purchase.","Sistemul va prelua materialele din depozitele selectate. Dacă nu este specificat, sistemul va crea o cerere materială pentru cumpărare.",
+Lead Time,Perioada de grație,
+PAN Details,Detalii PAN,
+Create Customer,Creați client,
+Invoicing,Facturare,
+Enable Auto Invoicing,Activați facturarea automată,
+Send Membership Acknowledgement,Trimiteți confirmarea de membru,
+Send Invoice with Email,Trimiteți factura prin e-mail,
+Membership Print Format,Formatul de tipărire a calității de membru,
+Invoice Print Format,Format de imprimare factură,
+Revoke <Key></Key>,Revoca&lt;Key&gt;&lt;/Key&gt;,
+You can learn more about memberships in the manual. ,Puteți afla mai multe despre abonamente în manual.,
+ERPNext Docs,Documente ERPNext,
+Regenerate Webhook Secret,Regenerați secretul Webhook,
+Generate Webhook Secret,Generați Webhook Secret,
+Copy Webhook URL,Copiați adresa URL Webhook,
+Linked Item,Element conectat,
+Is Recurring,Este recurent,
+HRA Exemption,Scutire HRA,
+Monthly House Rent,Închirierea lunară a casei,
+Rented in Metro City,Închiriat în Metro City,
+HRA as per Salary Structure,HRA conform structurii salariale,
+Annual HRA Exemption,Scutire anuală HRA,
+Monthly HRA Exemption,Scutire HRA lunară,
+House Rent Payment Amount,Suma plății chiriei casei,
+Rented From Date,Închiriat de la Data,
+Rented To Date,Închiriat până în prezent,
+Monthly Eligible Amount,Suma eligibilă lunară,
+Total Eligible HRA Exemption,Scutire HRA eligibilă totală,
+Validating Employee Attendance...,Validarea prezenței angajaților ...,
+Submitting Salary Slips and creating Journal Entry...,Trimiterea fișelor salariale și crearea intrării în jurnal ...,
+Calculate Payroll Working Days Based On,Calculați zilele lucrătoare de salarizare pe baza,
+Consider Unmarked Attendance As,Luați în considerare participarea nemarcată ca,
+Fraction of Daily Salary for Half Day,Fracțiunea salariului zilnic pentru jumătate de zi,
+Component Type,Tipul componentei,
+Provident Fund,Fondul Provident,
+Additional Provident Fund,Fondul Provident suplimentar,
+Provident Fund Loan,Împrumut pentru Fondul Provident,
+Professional Tax,Impozit profesional,
+Is Income Tax Component,Este componenta impozitului pe venit,
+Component properties and references ,Proprietăți și referințe ale componentelor,
+Additional Salary ,Salariu suplimentar,
+Unmarked days,Zile nemarcate,
+Absent Days,Zile absente,
+Conditions and Formula variable and example,Condiții și variabilă Formula și exemplu,
+Feedback By,Feedback de,
+Manufacturing Section,Secțiunea de fabricație,
+"By default, the Customer Name is set as per the Full Name entered. If you want Customers to be named by a ","În mod implicit, Numele clientului este setat conform Numelui complet introdus. Dacă doriți ca clienții să fie numiți de un",
+Configure the default Price List when creating a new Sales transaction. Item prices will be fetched from this Price List.,Configurați lista de prețuri implicită atunci când creați o nouă tranzacție de vânzări. Prețurile articolelor vor fi preluate din această listă de prețuri.,
+"If this option is configured 'Yes', ERPNext will prevent you from creating a Sales Invoice or Delivery Note without creating a Sales Order first. This configuration can be overridden for a particular Customer by enabling the 'Allow Sales Invoice Creation Without Sales Order' checkbox in the Customer master.","Dacă această opțiune este configurată „Da”, ERPNext vă va împiedica să creați o factură de vânzare sau o notă de livrare fără a crea mai întâi o comandă de vânzare. Această configurație poate fi anulată pentru un anumit Client activând caseta de selectare „Permite crearea facturii de vânzare fără comandă de vânzare” din masterul Clientului.",
+"If this option is configured 'Yes', ERPNext will prevent you from creating a Sales Invoice without creating a Delivery Note first. This configuration can be overridden for a particular Customer by enabling the 'Allow Sales Invoice Creation Without Delivery Note' checkbox in the Customer master.","Dacă această opțiune este configurată „Da”, ERPNext vă va împiedica să creați o factură de vânzare fără a crea mai întâi o notă de livrare. Această configurație poate fi suprascrisă pentru un anumit Client activând caseta de selectare „Permite crearea facturilor de vânzare fără notă de livrare” din masterul Clientului.",
+Default Warehouse for Sales Return,Depozit implicit pentru returnarea vânzărilor,
+Default In Transit Warehouse,Implicit în Depozitul de tranzit,
+Enable Perpetual Inventory For Non Stock Items,Activați inventarul perpetuu pentru articolele fără stoc,
+HRA Settings,Setări HRA,
+Basic Component,Componenta de bază,
+HRA Component,Componenta HRA,
+Arrear Component,Componenta Arrear,
+Please enter the company name to confirm,Vă rugăm să introduceți numele companiei pentru a confirma,
+Quotation Lost Reason Detail,Citat Detaliu motiv pierdut,
+Enable Variants,Activați variantele,
+Save Quotations as Draft,Salvați ofertele ca schiță,
+MAT-DN-RET-.YYYY.-,MAT-DN-RET-.YYYY.-,
+Please Select a Customer,Vă rugăm să selectați un client,
+Against Delivery Note Item,Împotriva articolului Note de livrare,
+Is Non GST ,Nu este GST,
+Image Description,Descrierea imaginii,
+Transfer Status,Stare transfer,
+MAT-PR-RET-.YYYY.-,MAT-PR-RET-.YYYY.-,
+Track this Purchase Receipt against any Project,Urmăriți această chitanță de cumpărare împotriva oricărui proiect,
+Please Select a Supplier,Vă rugăm să selectați un furnizor,
+Add to Transit,Adăugați la tranzit,
+Set Basic Rate Manually,Setați manual rata de bază,
+"By default, the Item Name is set as per the Item Code entered. If you want Items to be named by a ","În mod implicit, numele articolului este setat conform codului articolului introdus. Dacă doriți ca elementele să fie denumite de un",
+Set a Default Warehouse for Inventory Transactions. This will be fetched into the Default Warehouse in the Item master.,Setați un depozit implicit pentru tranzacțiile de inventar. Acest lucru va fi preluat în Depozitul implicit din elementul master.,
+"This will allow stock items to be displayed in negative values. Using this option depends on your use case. With this option unchecked, the system warns before obstructing a transaction that is causing negative stock.","Acest lucru va permite afișarea articolelor stoc în valori negative. Utilizarea acestei opțiuni depinde de cazul dvs. de utilizare. Cu această opțiune bifată, sistemul avertizează înainte de a obstrucționa o tranzacție care cauzează stoc negativ.",
+Choose between FIFO and Moving Average Valuation Methods. Click ,Alegeți între FIFO și metodele de evaluare medie mobile. Clic,
+ to know more about them.,să afle mai multe despre ele.,
+Show 'Scan Barcode' field above every child table to insert Items with ease.,Afișați câmpul „Scanare cod de bare” deasupra fiecărui tabel copil pentru a insera articole cu ușurință.,
+"Serial numbers for stock will be set automatically based on the Items entered based on first in first out in transactions like Purchase/Sales Invoices, Delivery Notes, etc.","Numerele de serie pentru stoc vor fi setate automat pe baza articolelor introduse pe baza primelor în primele ieșiri din tranzacții precum facturi de cumpărare / vânzare, note de livrare etc.",
+"If blank, parent Warehouse Account or company default will be considered in transactions","Dacă este necompletat, contul de depozit părinte sau prestabilitatea companiei vor fi luate în considerare în tranzacții",
+Service Level Agreement Details,Detalii acord nivel de serviciu,
+Service Level Agreement Status,Starea Acordului la nivel de serviciu,
+On Hold Since,În așteptare de când,
+Total Hold Time,Timp total de așteptare,
+Response Details,Detalii de răspuns,
+Average Response Time,Timpul mediu de răspuns,
+User Resolution Time,Ora de rezoluție a utilizatorului,
+SLA is on hold since {0},SLA este în așteptare de la {0},
+Pause SLA On Status,Întrerupeți SLA On Status,
+Pause SLA On,Întrerupeți SLA Activat,
+Greetings Section,Secțiunea Salutări,
+Greeting Title,Titlu de salut,
+Greeting Subtitle,Subtitrare de salut,
+Youtube ID,ID YouTube,
+Youtube Statistics,Statistici Youtube,
+Views,Vizualizări,
+Dislikes,Nu-mi place,
+Video Settings,Setari video,
+Enable YouTube Tracking,Activați urmărirea YouTube,
+30 mins,30 de minute,
+1 hr,1 oră,
+6 hrs,6 ore,
+Patient Progress,Progresul pacientului,
+Targetted,Țintit,
+Score Obtained,Scor obținut,
+Sessions,Sesiuni,
+Average Score,Scor mediu,
+Select Assessment Template,Selectați Șablon de evaluare,
+ out of ,din,
+Select Assessment Parameter,Selectați Parametru de evaluare,
+Gender: ,Gen:,
+Contact: ,A lua legatura:,
+Total Therapy Sessions: ,Total sesiuni de terapie:,
+Monthly Therapy Sessions: ,Sesiuni lunare de terapie:,
+Patient Profile,Profilul pacientului,
+Point Of Sale,Punct de vânzare,
+Email sent successfully.,Email-ul a fost trimis cu succes.,
+Search by invoice id or customer name,Căutați după ID-ul facturii sau numele clientului,
+Invoice Status,Starea facturii,
+Filter by invoice status,Filtrează după starea facturii,
+Select item group,Selectați grupul de articole,
+No items found. Scan barcode again.,Nu au fost gasite articolele. Scanați din nou codul de bare.,
+"Search by customer name, phone, email.","Căutare după numele clientului, telefon, e-mail.",
+Enter discount percentage.,Introduceți procentul de reducere.,
+Discount cannot be greater than 100%,Reducerea nu poate fi mai mare de 100%,
+Enter customer's email,Introduceți adresa de e-mail a clientului,
+Enter customer's phone number,Introduceți numărul de telefon al clientului,
+Customer contact updated successfully.,Contactul clientului a fost actualizat cu succes.,
+Item will be removed since no serial / batch no selected.,Elementul va fi eliminat deoarece nu este selectat niciun serial / lot.,
+Discount (%),Reducere (%),
+You cannot submit the order without payment.,Nu puteți trimite comanda fără plată.,
+You cannot submit empty order.,Nu puteți trimite o comandă goală.,
+To Be Paid,A fi platit,
+Create POS Opening Entry,Creați o intrare de deschidere POS,
+Please add Mode of payments and opening balance details.,Vă rugăm să adăugați detalii despre modul de plată și soldul de deschidere.,
+Toggle Recent Orders,Comutați comenzile recente,
+Save as Draft,Salvează ca ciornă,
+You must add atleast one item to save it as draft.,Trebuie să adăugați cel puțin un articol pentru al salva ca schiță.,
+There was an error saving the document.,A apărut o eroare la salvarea documentului.,
+You must select a customer before adding an item.,Trebuie să selectați un client înainte de a adăuga un articol.,
+Please Select a Company,Vă rugăm să selectați o companie,
+Active Leads,Oportunități active,
+Please Select a Company.,Vă rugăm să selectați o companie.,
+BOM Operations Time,Timp operații BOM,
+BOM ID,ID-ul BOM,
+BOM Item Code,Cod articol BOM,
+Time (In Mins),Timp (în minute),
+Sub-assembly BOM Count,Numărul BOM al subansamblului,
+View Type,Tipul de vizualizare,
+Total Delivered Amount,Suma totală livrată,
+Downtime Analysis,Analiza timpului de oprire,
+Machine,Mașinărie,
+Downtime (In Hours),Timp de inactivitate (în ore),
+Employee Analytics,Analiza angajaților,
+"""From date"" can not be greater than or equal to ""To date""",„De la dată” nu poate fi mai mare sau egal cu „Până în prezent”,
+Exponential Smoothing Forecasting,Previziune de netezire exponențială,
+First Response Time for Issues,Primul timp de răspuns pentru probleme,
+First Response Time for Opportunity,Primul timp de răspuns pentru oportunitate,
+Depreciatied Amount,Suma depreciată,
+Period Based On,Perioada bazată pe,
+Date Based On,Data bazată pe,
+{0} and {1} are mandatory,{0} și {1} sunt obligatorii,
+Consider Accounting Dimensions,Luați în considerare dimensiunile contabile,
+Income Tax Deductions,Deduceri de impozit pe venit,
+Income Tax Component,Componenta impozitului pe venit,
+Income Tax Amount,Suma impozitului pe venit,
+Reserved Quantity for Production,Cantitate rezervată pentru producție,
+Projected Quantity,Cantitatea proiectată,
+ Total Sales Amount,Suma totală a vânzărilor,
+Job Card Summary,Rezumatul fișei de muncă,
+Id,Id,
+Time Required (In Mins),Timp necesar (în minute),
+From Posting Date,De la data înregistrării,
+To Posting Date,Până la data de înregistrare,
+No records found,Nu au fost găsite,
+Customer/Lead Name,Numele clientului / clientului,
+Unmarked Days,Zile nemarcate,
+Jan,Ian,
+Feb,Februarie,
+Mar,Mar,
+Apr,Aprilie,
+Aug,Aug,
+Sep,Sept,
+Oct,Oct,
+Nov,Noiembrie,
+Dec,Dec,
+Summarized View,Vizualizare rezumată,
+Production Planning Report,Raport de planificare a producției,
+Order Qty,Comandați cantitatea,
+Raw Material Code,Codul materiei prime,
+Raw Material Name,Numele materiei prime,
+Allotted Qty,Cantitate alocată,
+Expected Arrival Date,Data de sosire preconizată,
+Arrival Quantity,Cantitatea de sosire,
+Raw Material Warehouse,Depozit de materii prime,
+Order By,Comandați după,
+Include Sub-assembly Raw Materials,Includeți subansamblarea materiilor prime,
+Professional Tax Deductions,Deduceri fiscale profesionale,
+Program wise Fee Collection,Colectarea taxelor în funcție de program,
+Fees Collected,Taxe colectate,
+Project Summary,Sumarul proiectului,
+Total Tasks,Total sarcini,
+Tasks Completed,Sarcini finalizate,
+Tasks Overdue,Sarcini restante,
+Completion,Completare,
+Provident Fund Deductions,Deduceri din fondul Provident,
+Purchase Order Analysis,Analiza comenzii de cumpărare,
+From and To Dates are required.,De la și până la date sunt necesare.,
+To Date cannot be before From Date.,To Date nu poate fi înainte de From Date.,
+Qty to Bill,Cantitate pentru Bill,
+Group by Purchase Order,Grupați după ordinul de cumpărare,
+ Purchase Value,Valoare de cumpărare,
+Total Received Amount,Suma totală primită,
+Quality Inspection Summary,Rezumatul inspecției calității,
+ Quoted Amount,Suma citată,
+Lead Time (Days),Timp de plumb (zile),
+Include Expired,Includeți Expirat,
+Recruitment Analytics,Analize de recrutare,
+Applicant name,Numele solicitantului,
+Job Offer status,Starea ofertei de muncă,
+On Date,La întălnire,
+Requested Items to Order and Receive,Articolele solicitate la comandă și primire,
+Salary Payments Based On Payment Mode,Plăți salariale bazate pe modul de plată,
+Salary Payments via ECS,Plăți salariale prin ECS,
+Account No,Cont nr,
+IFSC,IFSC,
+MICR,MICR,
+Sales Order Analysis,Analiza comenzilor de vânzare,
+Amount Delivered,Suma livrată,
+Delay (in Days),Întârziere (în zile),
+Group by Sales Order,Grupați după comanda de vânzare,
+ Sales Value,Valoarea vânzărilor,
+Stock Qty vs Serial No Count,Cantitate stoc vs număr fără serie,
+Serial No Count,Număr de serie,
+Work Order Summary,Rezumatul comenzii de lucru,
+Produce Qty,Produceți cantitatea,
+Lead Time (in mins),Durata de livrare (în minute),
+Charts Based On,Diagramele bazate pe,
+YouTube Interactions,Interacțiuni YouTube,
+Published Date,Data publicării,
+Barnch,Barnch,
+Select a Company,Selectați o companie,
+Opportunity {0} created,Oportunitate {0} creată,
+Kindly select the company first,Vă rugăm să selectați mai întâi compania,
+Please enter From Date and To Date to generate JSON,Vă rugăm să introduceți De la dată și până la data pentru a genera JSON,
+PF Account,Cont PF,
+PF Amount,Suma PF,
+Additional PF,PF suplimentar,
+PF Loan,Împrumut PF,
+Download DATEV File,Descărcați fișierul DATEV,
+Numero has not set in the XML file,Numero nu a fost setat în fișierul XML,
+Inward Supplies(liable to reverse charge),Consumabile interne (susceptibile de a inversa taxa),
+This is based on the course schedules of this Instructor,Aceasta se bazează pe programele de curs ale acestui instructor,
+Course and Assessment,Curs și evaluare,
+Course {0} has been added to all the selected programs successfully.,Cursul {0} a fost adăugat cu succes la toate programele selectate.,
+Programs updated,Programe actualizate,
+Program and Course,Program și curs,
+{0} or {1} is mandatory,{0} sau {1} este obligatoriu,
+Mandatory Fields,Câmpuri obligatorii,
+Student {0}: {1} does not belong to Student Group {2},Student {0}: {1} nu aparține grupului de studenți {2},
+Student Attendance record {0} already exists against the Student {1},Înregistrarea prezenței studenților {0} există deja împotriva studentului {1},
+Duplicate Entry,Intrare duplicat,
+Course and Fee,Curs și Taxă,
+Not eligible for the admission in this program as per Date Of Birth,Nu este eligibil pentru admiterea în acest program conform datei nașterii,
+Topic {0} has been added to all the selected courses successfully.,Subiectul {0} a fost adăugat cu succes la toate cursurile selectate.,
+Courses updated,Cursuri actualizate,
+{0} {1} has been added to all the selected topics successfully.,{0} {1} a fost adăugat cu succes la toate subiectele selectate.,
+Topics updated,Subiecte actualizate,
+Academic Term and Program,Termen academic și program,
+Please remove this item and try to submit again or update the posting time.,Eliminați acest articol și încercați să trimiteți din nou sau să actualizați ora de postare.,
+Failed to Authenticate the API key.,Autentificarea cheii API nu a reușit.,
+Invalid Credentials,Acreditări nevalide,
+URL can only be a string,Adresa URL poate fi doar un șir,
+"Here is your webhook secret, this will be shown to you only once.","Iată secretul tău webhook, acesta îți va fi afișat o singură dată.",
+The payment for this membership is not paid. To generate invoice fill the payment details,Plata pentru acest membru nu este plătită. Pentru a genera factura completați detaliile de plată,
+An invoice is already linked to this document,O factură este deja legată de acest document,
+No customer linked to member {},Niciun client legat de membru {},
+You need to set <b>Debit Account</b> in Membership Settings,Trebuie să setați <b>Cont de debit</b> în Setări de membru,
+You need to set <b>Default Company</b> for invoicing in Membership Settings,Trebuie să setați <b>Compania implicită</b> pentru facturare în Setări de membru,
+You need to enable <b>Send Acknowledge Email</b> in Membership Settings,Trebuie să activați <b>Trimitere e-mail de confirmare</b> în setările de membru,
+Error creating membership entry for {0},Eroare la crearea intrării de membru pentru {0},
+A customer is already linked to this Member,Un client este deja legat de acest membru,
+End Date must not be lesser than Start Date,Data de încheiere nu trebuie să fie mai mică decât Data de începere,
+Employee {0} already has Active Shift {1}: {2},Angajatul {0} are deja Active Shift {1}: {2},
+ from {0},de la {0},
+ to {0},către {0},
+Please select Employee first.,Vă rugăm să selectați mai întâi Angajat.,
+Please set {0} for the Employee or for Department: {1},Vă rugăm să setați {0} pentru angajat sau pentru departament: {1},
+To Date should be greater than From Date,To Date ar trebui să fie mai mare decât From Date,
+Employee Onboarding: {0} is already for Job Applicant: {1},Integrarea angajaților: {0} este deja pentru solicitantul de post: {1},
+Job Offer: {0} is already for Job Applicant: {1},Ofertă de locuri de muncă: {0} este deja pentru solicitantul de post: {1},
+Only Shift Request with status 'Approved' and 'Rejected' can be submitted,Numai cererea Shift cu starea „Aprobat” și „Respins” poate fi trimisă,
+Shift Assignment: {0} created for Employee: {1},Atribuire schimbare: {0} creată pentru angajat: {1},
+You can not request for your Default Shift: {0},Nu puteți solicita schimbarea implicită: {0},
+Only Approvers can Approve this Request.,Numai aprobatorii pot aproba această solicitare.,
+Asset Value Analytics,Analiza valorii activelor,
+Category-wise Asset Value,Valoarea activelor în funcție de categorie,
+Total Assets,Total active,
+New Assets (This Year),Active noi (anul acesta),
+Row #{}: Depreciation Posting Date should not be equal to Available for Use Date.,Rândul {{}: Data de înregistrare a amortizării nu trebuie să fie egală cu Disponibil pentru data de utilizare.,
+Incorrect Date,Data incorectă,
+Invalid Gross Purchase Amount,Suma brută de achiziție nevalidă,
+There are active maintenance or repairs against the asset. You must complete all of them before cancelling the asset.,Există activități de întreținere sau reparații active asupra activului. Trebuie să le completați pe toate înainte de a anula activul.,
+% Complete,% Complet,
+Back to Course,Înapoi la curs,
+Finish Topic,Finalizați subiectul,
+Mins,Min,
+by,de,
+Back to,Înapoi la,
+Enrolling...,Se înscrie ...,
+You have successfully enrolled for the program ,V-ați înscris cu succes la program,
+Enrolled,Înscris,
+Watch Intro,Urmăriți Introducere,
+We're here to help!,Suntem aici pentru a vă ajuta!,
+Frequently Read Articles,Citiți frecvent articole,
+Please set a default company address,Vă rugăm să setați o adresă implicită a companiei,
+{0} is not a valid state! Check for typos or enter the ISO code for your state.,{0} nu este o stare validă! Verificați dacă există greșeli sau introduceți codul ISO pentru starea dvs.,
+Error occured while parsing Chart of Accounts: Please make sure that no two accounts have the same name,A apărut o eroare la analizarea planului de conturi: asigurați-vă că niciun cont nu are același nume,
+Plaid invalid request error,Eroare solicitare invalidă în carouri,
+Please check your Plaid client ID and secret values,Vă rugăm să verificați ID-ul dvs. de client Plaid și valorile secrete,
+Bank transaction creation error,Eroare la crearea tranzacțiilor bancare,
+Unit of Measurement,Unitate de măsură,
+Fiscal Year {0} Does Not Exist,Anul fiscal {0} nu există,
+Row # {0}: Returned Item {1} does not exist in {2} {3},Rândul # {0}: articolul returnat {1} nu există în {2} {3},
+Valuation type charges can not be marked as Inclusive,Taxele de tip de evaluare nu pot fi marcate ca Incluse,
+You do not have permissions to {} items in a {}.,Nu aveți permisiuni pentru {} articole dintr-un {}.,
+Insufficient Permissions,Permisiuni insuficiente,
+You are not allowed to update as per the conditions set in {} Workflow.,Nu aveți permisiunea de a actualiza conform condițiilor stabilite în {} Workflow.,
+Expense Account Missing,Cont de cheltuieli lipsește,
+{0} is not a valid Value for Attribute {1} of Item {2}.,{0} nu este o valoare validă pentru atributul {1} al articolului {2}.,
+Invalid Value,Valoare invalida,
+The value {0} is already assigned to an existing Item {1}.,Valoarea {0} este deja alocată unui articol existent {1}.,
+"To still proceed with editing this Attribute Value, enable {0} in Item Variant Settings.","Pentru a continua să editați această valoare a atributului, activați {0} în Setări pentru varianta articolului.",
+Edit Not Allowed,Editarea nu este permisă,
+Row #{0}: Item {1} is already fully received in Purchase Order {2},Rândul nr. {0}: Articolul {1} este deja complet primit în Comanda de cumpărare {2},
+You cannot create or cancel any accounting entries with in the closed Accounting Period {0},Nu puteți crea sau anula nicio înregistrare contabilă în perioada de contabilitate închisă {0},
+POS Invoice should have {} field checked.,Factura POS ar trebui să aibă selectat câmpul {}.,
+Invalid Item,Element nevalid,
+Row #{}: You cannot add postive quantities in a return invoice. Please remove item {} to complete the return.,Rândul # {}: nu puteți adăuga cantități postive într-o factură de returnare. Eliminați articolul {} pentru a finaliza returnarea.,
+The selected change account {} doesn't belongs to Company {}.,Contul de modificare selectat {} nu aparține companiei {}.,
+Atleast one invoice has to be selected.,Trebuie selectată cel puțin o factură.,
+Payment methods are mandatory. Please add at least one payment method.,Metodele de plată sunt obligatorii. Vă rugăm să adăugați cel puțin o metodă de plată.,
+Please select a default mode of payment,Vă rugăm să selectați un mod de plată implicit,
+You can only select one mode of payment as default,Puteți selecta doar un mod de plată ca prestabilit,
+Missing Account,Cont lipsă,
+Customers not selected.,Clienții nu sunt selectați.,
+Statement of Accounts,Declarație de conturi,
+Ageing Report Based On ,Raport de îmbătrânire bazat pe,
+Please enter distributed cost center,Vă rugăm să introduceți centrul de cost distribuit,
+Total percentage allocation for distributed cost center should be equal to 100,Alocarea procentuală totală pentru centrul de cost distribuit ar trebui să fie egală cu 100,
+Cannot enable Distributed Cost Center for a Cost Center already allocated in another Distributed Cost Center,Nu se poate activa Centrul de costuri distribuite pentru un centru de costuri deja alocat într-un alt centru de costuri distribuite,
+Parent Cost Center cannot be added in Distributed Cost Center,Centrul de costuri părinte nu poate fi adăugat în Centrul de costuri distribuite,
+A Distributed Cost Center cannot be added in the Distributed Cost Center allocation table.,Un centru de costuri distribuite nu poate fi adăugat în tabelul de alocare a centrului de costuri distribuite.,
+Cost Center with enabled distributed cost center can not be converted to group,Centrul de costuri cu centrul de costuri distribuite activat nu poate fi convertit în grup,
+Cost Center Already Allocated in a Distributed Cost Center cannot be converted to group,Centrul de cost deja alocat într-un centru de cost distribuit nu poate fi convertit în grup,
+Trial Period Start date cannot be after Subscription Start Date,Perioada de încercare Data de începere nu poate fi ulterioară datei de începere a abonamentului,
+Subscription End Date must be after {0} as per the subscription plan,Data de încheiere a abonamentului trebuie să fie după {0} conform planului de abonament,
+Subscription End Date is mandatory to follow calendar months,Data de încheiere a abonamentului este obligatorie pentru a urma lunile calendaristice,
+Row #{}: POS Invoice {} is not against customer {},Rândul # {}: factura POS {} nu este împotriva clientului {},
+Row #{}: POS Invoice {} is not submitted yet,Rândul # {}: factura POS {} nu a fost încă trimisă,
+Row #{}: POS Invoice {} has been {},Rândul # {}: factura POS {} a fost {},
+No Supplier found for Inter Company Transactions which represents company {0},Nu a fost găsit niciun furnizor pentru tranzacțiile între companii care să reprezinte compania {0},
+No Customer found for Inter Company Transactions which represents company {0},Nu a fost găsit niciun client pentru tranzacțiile între companii care reprezintă compania {0},
+Invalid Period,Perioadă nevalidă,
+Selected POS Opening Entry should be open.,Intrarea selectată de deschidere POS ar trebui să fie deschisă.,
+Invalid Opening Entry,Intrare de deschidere nevalidă,
+Please set a Company,Vă rugăm să setați o companie,
+"Sorry, this coupon code's validity has not started","Ne pare rău, valabilitatea acestui cod cupon nu a început",
+"Sorry, this coupon code's validity has expired","Ne pare rău, valabilitatea acestui cod de cupon a expirat",
+"Sorry, this coupon code is no longer valid","Ne pare rău, acest cod de cupon nu mai este valid",
+For the 'Apply Rule On Other' condition the field {0} is mandatory,"Pentru condiția „Aplică regula la altele”, câmpul {0} este obligatoriu",
+{1} Not in Stock,{1} Nu este în stoc,
+Only {0} in Stock for item {1},Numai {0} în stoc pentru articolul {1},
+Please enter a coupon code,Vă rugăm să introduceți un cod de cupon,
+Please enter a valid coupon code,Vă rugăm să introduceți un cod de cupon valid,
+Invalid Child Procedure,Procedură copil nevalidă,
+Import Italian Supplier Invoice.,Importați factura furnizorului italian.,
+"Valuation Rate for the Item {0}, is required to do accounting entries for {1} {2}.","Rata de evaluare pentru articolul {0}, este necesară pentru a face înregistrări contabile pentru {1} {2}.",
+ Here are the options to proceed:,Iată opțiunile pentru a continua:,
+"If the item is transacting as a Zero Valuation Rate item in this entry, please enable 'Allow Zero Valuation Rate' in the {0} Item table.","Dacă articolul tranzacționează ca articol cu o rată de evaluare zero în această intrare, activați „Permiteți o rată de evaluare zero” în tabelul {0} Articol.",
+"If not, you can Cancel / Submit this entry ","Dacă nu, puteți anula / trimite această intrare",
+ performing either one below:,efectuând una dintre cele de mai jos:,
+Create an incoming stock transaction for the Item.,Creați o tranzacție de stoc primită pentru articol.,
+Mention Valuation Rate in the Item master.,Menționați rata de evaluare în elementul master.,
+Valuation Rate Missing,Rata de evaluare lipsește,
+Serial Nos Required,Numere de serie necesare,
+Quantity Mismatch,Cantitate necorespunzătoare,
+"Please Restock Items and Update the Pick List to continue. To discontinue, cancel the Pick List.","Vă rugăm să reporniți articolele și să actualizați lista de alegeri pentru a continua. Pentru a întrerupe, anulați lista de alegeri.",
+Out of Stock,Stoc epuizat,
+{0} units of Item {1} is not available.,{0} unități de articol {1} nu sunt disponibile.,
+Item for row {0} does not match Material Request,Elementul pentru rândul {0} nu se potrivește cu Cererea de material,
+Warehouse for row {0} does not match Material Request,Depozitul pentru rândul {0} nu se potrivește cu Cererea de material,
+Accounting Entry for Service,Intrare contabilă pentru service,
+All items have already been Invoiced/Returned,Toate articolele au fost deja facturate / returnate,
+All these items have already been Invoiced/Returned,Toate aceste articole au fost deja facturate / returnate,
+Stock Reconciliations,Reconcilieri stocuri,
+Merge not allowed,Îmbinarea nu este permisă,
+The following deleted attributes exist in Variants but not in the Template. You can either delete the Variants or keep the attribute(s) in template.,"Următoarele atribute șterse există în variante, dar nu în șablon. Puteți șterge variantele sau puteți păstra atributele în șablon.",
+Variant Items,Elemente variante,
+Variant Attribute Error,Eroare a atributului variantei,
+The serial no {0} does not belong to item {1},Numărul de serie {0} nu aparține articolului {1},
+There is no batch found against the {0}: {1},Nu există niciun lot găsit împotriva {0}: {1},
+Completed Operation,Operațiune finalizată,
+Work Order Analysis,Analiza comenzii de lucru,
+Quality Inspection Analysis,Analiza inspecției calității,
+Pending Work Order,Ordin de lucru în așteptare,
+Last Month Downtime Analysis,Analiza timpului de nefuncționare de luna trecută,
+Work Order Qty Analysis,Analiza cantității comenzii de lucru,
+Job Card Analysis,Analiza fișei de muncă,
+Monthly Total Work Orders,Comenzi lunare totale de lucru,
+Monthly Completed Work Orders,Comenzi de lucru finalizate lunar,
+Ongoing Job Cards,Carduri de muncă în curs,
+Monthly Quality Inspections,Inspecții lunare de calitate,
+(Forecast),(Prognoza),
+Total Demand (Past Data),Cerere totală (date anterioare),
+Total Forecast (Past Data),Prognoză totală (date anterioare),
+Total Forecast (Future Data),Prognoză totală (date viitoare),
+Based On Document,Pe baza documentului,
+Based On Data ( in years ),Pe baza datelor (în ani),
+Smoothing Constant,Netezire constantă,
+Please fill the Sales Orders table,Vă rugăm să completați tabelul Comenzi de vânzare,
+Sales Orders Required,Sunt necesare comenzi de vânzare,
+Please fill the Material Requests table,Vă rugăm să completați tabelul Cereri de materiale,
+Material Requests Required,Cereri materiale necesare,
+Items to Manufacture are required to pull the Raw Materials associated with it.,Articolele de fabricație sunt necesare pentru a extrage materiile prime asociate acestuia.,
+Items Required,Elemente necesare,
+Operation {0} does not belong to the work order {1},Operația {0} nu aparține comenzii de lucru {1},
+Print UOM after Quantity,Imprimați UOM după Cantitate,
+Set default {0} account for perpetual inventory for non stock items,Setați contul {0} implicit pentru inventarul perpetuu pentru articolele care nu sunt în stoc,
+Loan Security {0} added multiple times,Securitatea împrumutului {0} adăugată de mai multe ori,
+Loan Securities with different LTV ratio cannot be pledged against one loan,Titlurile de împrumut cu un raport LTV diferit nu pot fi gajate împotriva unui singur împrumut,
+Qty or Amount is mandatory for loan security!,Cantitatea sau suma este obligatorie pentru securitatea împrumutului!,
+Only submittted unpledge requests can be approved,Numai cererile unpledge trimise pot fi aprobate,
+Interest Amount or Principal Amount is mandatory,Suma dobânzii sau suma principală este obligatorie,
+Disbursed Amount cannot be greater than {0},Suma plătită nu poate fi mai mare de {0},
+Row {0}: Loan Security {1} added multiple times,Rândul {0}: Securitatea împrumutului {1} adăugat de mai multe ori,
+Row #{0}: Child Item should not be a Product Bundle. Please remove Item {1} and Save,Rândul # {0}: articolul secundar nu trebuie să fie un pachet de produse. Eliminați articolul {1} și Salvați,
+Credit limit reached for customer {0},Limita de credit atinsă pentru clientul {0},
+Could not auto create Customer due to the following missing mandatory field(s):,Nu s-a putut crea automat Clientul din cauza următoarelor câmpuri obligatorii lipsă:,
+Please create Customer from Lead {0}.,Vă rugăm să creați Client din Lead {0}.,
+Mandatory Missing,Obligatoriu Lipsește,
+Please set Payroll based on in Payroll settings,Vă rugăm să setați salarizarea pe baza setărilor de salarizare,
+Additional Salary: {0} already exist for Salary Component: {1} for period {2} and {3},Salariu suplimentar: {0} există deja pentru componenta salariu: {1} pentru perioada {2} și {3},
+From Date can not be greater than To Date.,From Date nu poate fi mai mare decât To Date.,
+Payroll date can not be less than employee's joining date.,Data salarizării nu poate fi mai mică decât data aderării angajatului.,
+From date can not be less than employee's joining date.,De la data nu poate fi mai mică decât data aderării angajatului.,
+To date can not be greater than employee's relieving date.,Până în prezent nu poate fi mai mare decât data de eliberare a angajatului.,
+Payroll date can not be greater than employee's relieving date.,Data salarizării nu poate fi mai mare decât data de scutire a angajatului.,
+Row #{0}: Please enter the result value for {1},Rândul # {0}: introduceți valoarea rezultatului pentru {1},
+Mandatory Results,Rezultate obligatorii,
+Sales Invoice or Patient Encounter is required to create Lab Tests,Factura de vânzare sau întâlnirea pacientului sunt necesare pentru a crea teste de laborator,
+Insufficient Data,Date insuficiente,
+Lab Test(s) {0} created successfully,Testele de laborator {0} au fost create cu succes,
+Test :,Test :,
+Sample Collection {0} has been created,A fost creată colecția de probe {0},
+Normal Range: ,Gama normală:,
+Row #{0}: Check Out datetime cannot be less than Check In datetime,Rândul # {0}: data de check out nu poate fi mai mică decât data de check in,
+"Missing required details, did not create Inpatient Record","Lipsesc detaliile solicitate, nu s-a creat înregistrarea internată",
+Unbilled Invoices,Facturi nefacturate,
+Standard Selling Rate should be greater than zero.,Rata de vânzare standard ar trebui să fie mai mare decât zero.,
+Conversion Factor is mandatory,Factorul de conversie este obligatoriu,
+Row #{0}: Conversion Factor is mandatory,Rândul # {0}: factorul de conversie este obligatoriu,
+Sample Quantity cannot be negative or 0,Cantitatea eșantionului nu poate fi negativă sau 0,
+Invalid Quantity,Cantitate nevalidă,
+"Please set defaults for Customer Group, Territory and Selling Price List in Selling Settings","Vă rugăm să setați valorile implicite pentru grupul de clienți, teritoriu și lista de prețuri de vânzare din setările de vânzare",
+{0} on {1},{0} pe {1},
+{0} with {1},{0} cu {1},
+Appointment Confirmation Message Not Sent,Mesajul de confirmare a programării nu a fost trimis,
+"SMS not sent, please check SMS Settings","SMS-ul nu a fost trimis, verificați Setările SMS",
+Healthcare Service Unit Type cannot have both {0} and {1},"Tipul unității de servicii medicale nu poate avea atât {0}, cât și {1}",
+Healthcare Service Unit Type must allow atleast one among {0} and {1},Tipul unității de servicii medicale trebuie să permită cel puțin unul dintre {0} și {1},
+Set Response Time and Resolution Time for Priority {0} in row {1}.,Setați timpul de răspuns și timpul de rezoluție pentru prioritatea {0} în rândul {1}.,
+Response Time for {0} priority in row {1} can't be greater than Resolution Time.,Timpul de răspuns pentru {0} prioritatea în rândul {1} nu poate fi mai mare decât timpul de rezoluție.,
+{0} is not enabled in {1},{0} nu este activat în {1},
+Group by Material Request,Grupați după cerere de material,
+Email Sent to Supplier {0},E-mail trimis către furnizor {0},
+"The Access to Request for Quotation From Portal is Disabled. To Allow Access, Enable it in Portal Settings.","Accesul la cererea de ofertă de la portal este dezactivat. Pentru a permite accesul, activați-l în Setări portal.",
+Supplier Quotation {0} Created,Ofertă furnizor {0} creată,
+Valid till Date cannot be before Transaction Date,Valabil până la data nu poate fi înainte de data tranzacției,
+Unlink Advance Payment on Cancellation of Order,Deconectați plata în avans la anularea comenzii,
+"Simple Python Expression, Example: territory != 'All Territories'","Expresie simplă Python, Exemplu: teritoriu! = „Toate teritoriile”",
+Sales Contributions and Incentives,Contribuții la vânzări și stimulente,
+Sourced by Supplier,Aprovizionat de furnizor,
+Total weightage assigned should be 100%.<br>It is {0},Ponderea totală alocată ar trebui să fie de 100%.<br> Este {0},
+Account {0} exists in parent company {1}.,Contul {0} există în compania mamă {1}.,
+"To overrule this, enable '{0}' in company {1}","Pentru a ignora acest lucru, activați „{0}” în companie {1}",
+Invalid condition expression,Expresie de condiție nevalidă,
+Please Select a Company First,Vă rugăm să selectați mai întâi o companie,
+Please Select Both Company and Party Type First,"Vă rugăm să selectați mai întâi atât compania, cât și tipul de petrecere",
+Provide the invoice portion in percent,Furnizați partea de facturare în procente,
+Give number of days according to prior selection,Dați numărul de zile în funcție de selecția anterioară,
+Email Details,Detalii e-mail,
+"Select a greeting for the receiver. E.g. Mr., Ms., etc.","Selectați o felicitare pentru receptor. De exemplu, domnul, doamna etc.",
+Preview Email,Previzualizați e-mailul,
+Please select a Supplier,Vă rugăm să selectați un furnizor,
+Supplier Lead Time (days),Timp de livrare a furnizorului (zile),
+"Home, Work, etc.","Acasă, serviciu etc.",
+Exit Interview Held On,Ieșiți din interviu,
+Condition and formula,Stare și formulă,
+Sets 'Target Warehouse' in each row of the Items table.,Setează „Depozit țintă” în fiecare rând al tabelului Elemente.,
+Sets 'Source Warehouse' in each row of the Items table.,Setează „Depozit sursă” în fiecare rând al tabelului Elemente.,
+POS Register,Registrul POS,
+"Can not filter based on POS Profile, if grouped by POS Profile","Nu se poate filtra pe baza profilului POS, dacă este grupat după profilul POS",
+"Can not filter based on Customer, if grouped by Customer","Nu se poate filtra pe baza clientului, dacă este grupat după client",
+"Can not filter based on Cashier, if grouped by Cashier","Nu se poate filtra în funcție de Casier, dacă este grupat după Casier",
+Payment Method,Modalitate de plată,
+"Can not filter based on Payment Method, if grouped by Payment Method","Nu se poate filtra pe baza metodei de plată, dacă este grupată după metoda de plată",
+Supplier Quotation Comparison,Compararea ofertelor de ofertă,
+Price per Unit (Stock UOM),Preț per unitate (stoc UOM),
+Group by Supplier,Grup pe furnizor,
+Group by Item,Grupați după articol,
+Remember to set {field_label}. It is required by {regulation}.,Nu uitați să setați {field_label}. Este cerut de {regulament}.,
+Enrollment Date cannot be before the Start Date of the Academic Year {0},Data înscrierii nu poate fi înainte de data de începere a anului academic {0},
+Enrollment Date cannot be after the End Date of the Academic Term {0},Data înscrierii nu poate fi ulterioară datei de încheiere a termenului academic {0},
+Enrollment Date cannot be before the Start Date of the Academic Term {0},Data înscrierii nu poate fi anterioară datei de începere a termenului academic {0},
+Future Posting Not Allowed,Postarea viitoare nu este permisă,
+"To enable Capital Work in Progress Accounting, ","Pentru a permite contabilitatea activității de capital în curs,",
+you must select Capital Work in Progress Account in accounts table,trebuie să selectați Contul de capital în curs în tabelul de conturi,
+You can also set default CWIP account in Company {},"De asemenea, puteți seta contul CWIP implicit în Companie {}",
+The Request for Quotation can be accessed by clicking on the following button,Cererea de ofertă poate fi accesată făcând clic pe butonul următor,
+Regards,Salutari,
+Please click on the following button to set your new password,Vă rugăm să faceți clic pe următorul buton pentru a seta noua parolă,
+Update Password,Actualizați parola,
+Row #{}: Selling rate for item {} is lower than its {}. Selling {} should be atleast {},Rândul # {}: rata de vânzare a articolului {} este mai mică decât {}. Vânzarea {} ar trebui să fie cel puțin {},
+You can alternatively disable selling price validation in {} to bypass this validation.,Puteți dezactiva alternativ validarea prețului de vânzare în {} pentru a ocoli această validare.,
+Invalid Selling Price,Preț de vânzare nevalid,
+Address needs to be linked to a Company. Please add a row for Company in the Links table.,Adresa trebuie să fie legată de o companie. Vă rugăm să adăugați un rând pentru Companie în tabelul Legături.,
+Company Not Linked,Compania nu este legată,
+Import Chart of Accounts from CSV / Excel files,Importați planul de conturi din fișiere CSV / Excel,
+Completed Qty cannot be greater than 'Qty to Manufacture',Cantitatea completată nu poate fi mai mare decât „Cantitatea pentru fabricare”,
+"Row {0}: For Supplier {1}, Email Address is Required to send an email","Rândul {0}: pentru furnizor {1}, este necesară adresa de e-mail pentru a trimite un e-mail",
+"If enabled, the system will post accounting entries for inventory automatically","Dacă este activat, sistemul va înregistra automat înregistrări contabile pentru inventar",
+Accounts Frozen Till Date,Conturi congelate până la data,
+Accounting entries are frozen up to this date. Nobody can create or modify entries except users with the role specified below,"Înregistrările contabile sunt înghețate până la această dată. Nimeni nu poate crea sau modifica intrări, cu excepția utilizatorilor cu rolul specificat mai jos",
+Role Allowed to Set Frozen Accounts and Edit Frozen Entries,Rolul permis pentru setarea conturilor înghețate și editarea intrărilor înghețate,
+Address used to determine Tax Category in transactions,Adresa utilizată pentru determinarea categoriei fiscale în tranzacții,
+"The percentage you are allowed to bill more against the amount ordered. For example, if the order value is $100 for an item and tolerance is set as 10%, then you are allowed to bill up to $110 ","Procentul pe care vi se permite să îl facturați mai mult pentru suma comandată. De exemplu, dacă valoarea comenzii este de 100 USD pentru un articol și toleranța este setată la 10%, atunci aveți permisiunea de a factura până la 110 USD",
+This role is allowed to submit transactions that exceed credit limits,Acest rol este permis să trimită tranzacții care depășesc limitele de credit,
+"If ""Months"" is selected, a fixed amount will be booked as deferred revenue or expense for each month irrespective of the number of days in a month. It will be prorated if deferred revenue or expense is not booked for an entire month","Dacă este selectată „Luni”, o sumă fixă va fi înregistrată ca venit sau cheltuială amânată pentru fiecare lună, indiferent de numărul de zile dintr-o lună. Acesta va fi proporțional dacă veniturile sau cheltuielile amânate nu sunt înregistrate pentru o lună întreagă",
+"If this is unchecked, direct GL entries will be created to book deferred revenue or expense","Dacă acest lucru nu este bifat, vor fi create intrări GL directe pentru a înregistra venituri sau cheltuieli amânate",
+Show Inclusive Tax in Print,Afișați impozitul inclus în tipar,
+Only select this if you have set up the Cash Flow Mapper documents,Selectați acest lucru numai dacă ați configurat documentele Cartografierii fluxurilor de numerar,
+Payment Channel,Canal de plată,
+Is Purchase Order Required for Purchase Invoice & Receipt Creation?,Este necesară comanda de cumpărare pentru crearea facturii de achiziție și a chitanței?,
+Is Purchase Receipt Required for Purchase Invoice Creation?,Este necesară chitanța de cumpărare pentru crearea facturii de cumpărare?,
+Maintain Same Rate Throughout the Purchase Cycle,Mențineți aceeași rată pe tot parcursul ciclului de cumpărare,
+Allow Item To Be Added Multiple Times in a Transaction,Permiteți adăugarea articolului de mai multe ori într-o tranzacție,
+Suppliers,Furnizori,
+Send Emails to Suppliers,Trimiteți e-mailuri furnizorilor,
+Select a Supplier,Selectați un furnizor,
+Cannot mark attendance for future dates.,Nu se poate marca prezența pentru date viitoare.,
+Do you want to update attendance? <br> Present: {0} <br> Absent: {1},Doriți să actualizați prezența?<br> Prezent: {0}<br> Absent: {1},
+Mpesa Settings,Setări Mpesa,
+Initiator Name,Numele inițiatorului,
+Till Number,Până la numărul,
+Sandbox,Sandbox,
+ Online PassKey,Online PassKey,
+Security Credential,Acreditare de securitate,
+Get Account Balance,Obțineți soldul contului,
+Please set the initiator name and the security credential,Vă rugăm să setați numele inițiatorului și acreditările de securitate,
+Inpatient Medication Entry,Intrarea în medicamente pentru pacienții internați,
+HLC-IME-.YYYY.-,HLC-IME-.YYYY.-,
+Item Code (Drug),Cod articol (medicament),
+Medication Orders,Comenzi de medicamente,
+Get Pending Medication Orders,Obțineți comenzi de medicamente în așteptare,
+Inpatient Medication Orders,Comenzi pentru medicamente internate,
+Medication Warehouse,Depozit de medicamente,
+Warehouse from where medication stock should be consumed,Depozit de unde ar trebui consumat stocul de medicamente,
+Fetching Pending Medication Orders,Preluarea comenzilor de medicamente în așteptare,
+Inpatient Medication Entry Detail,Detalii privind intrarea medicamentelor pentru pacienții internați,
+Medication Details,Detalii despre medicamente,
+Drug Code,Codul drogurilor,
+Drug Name,Numele medicamentului,
+Against Inpatient Medication Order,Împotriva ordinului privind medicamentul internat,
+Against Inpatient Medication Order Entry,Împotriva introducerii comenzii pentru medicamente internate,
+Inpatient Medication Order,Ordinul privind medicamentul internat,
+HLC-IMO-.YYYY.-,HLC-IMO-.YYYY.-,
+Total Orders,Total comenzi,
+Completed Orders,Comenzi finalizate,
+Add Medication Orders,Adăugați comenzi de medicamente,
+Adding Order Entries,Adăugarea intrărilor de comandă,
+{0} medication orders completed,{0} comenzi de medicamente finalizate,
+{0} medication order completed,{0} comandă de medicamente finalizată,
+Inpatient Medication Order Entry,Intrarea comenzii pentru medicamente internate,
+Is Order Completed,Comanda este finalizată,
+Employee Records to Be Created By,Înregistrările angajaților care trebuie create de,
+Employee records are created using the selected field,Înregistrările angajaților sunt create folosind câmpul selectat,
+Don't send employee birthday reminders,Nu trimiteți memento-uri de ziua angajaților,
+Restrict Backdated Leave Applications,Restricționează aplicațiile de concediu actualizate,
+Sequence ID,ID secvență,
+Sequence Id,Secvența Id,
+Allow multiple material consumptions against a Work Order,Permiteți mai multe consumuri de materiale împotriva unei comenzi de lucru,
+Plan time logs outside Workstation working hours,Planificați jurnalele de timp în afara programului de lucru al stației de lucru,
+Plan operations X days in advance,Planificați operațiunile cu X zile înainte,
+Time Between Operations (Mins),Timpul dintre operații (min.),
+Default: 10 mins,Implicit: 10 minute,
+Overproduction for Sales and Work Order,Supraproducție pentru vânzări și comandă de lucru,
+"Update BOM cost automatically via scheduler, based on the latest Valuation Rate/Price List Rate/Last Purchase Rate of raw materials","Actualizați automat costul BOM prin programator, pe baza celei mai recente rate de evaluare / tarif de listă de prețuri / ultimul procent de cumpărare a materiilor prime",
+Purchase Order already created for all Sales Order items,Comanda de cumpărare deja creată pentru toate articolele comenzii de vânzare,
+Select Items,Selectați elemente,
+Against Default Supplier,Împotriva furnizorului implicit,
+Auto close Opportunity after the no. of days mentioned above,Închidere automată Oportunitate după nr. de zile menționate mai sus,
+Is Sales Order Required for Sales Invoice & Delivery Note Creation?,Este necesară comanda de vânzare pentru crearea facturilor de vânzare și a notelor de livrare?,
+Is Delivery Note Required for Sales Invoice Creation?,Este necesară nota de livrare pentru crearea facturii de vânzare?,
+How often should Project and Company be updated based on Sales Transactions?,Cât de des ar trebui actualizate proiectul și compania pe baza tranzacțiilor de vânzare?,
+Allow User to Edit Price List Rate in Transactions,Permiteți utilizatorului să editeze rata listei de prețuri în tranzacții,
+Allow Item to Be Added Multiple Times in a Transaction,Permiteți adăugarea articolului de mai multe ori într-o tranzacție,
+Allow Multiple Sales Orders Against a Customer's Purchase Order,Permiteți mai multe comenzi de vânzare împotriva comenzii de cumpărare a unui client,
+Validate Selling Price for Item Against Purchase Rate or Valuation Rate,Validați prețul de vânzare al articolului împotriva ratei de achiziție sau a ratei de evaluare,
+Hide Customer's Tax ID from Sales Transactions,Ascundeți codul fiscal al clientului din tranzacțiile de vânzare,
+"The 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 pe care vi se permite să îl primiți sau să livrați mai mult în raport cu cantitatea comandată. De exemplu, dacă ați comandat 100 de unități, iar alocația dvs. este de 10%, atunci aveți permisiunea de a primi 110 unități.",
+Action If Quality Inspection Is Not Submitted,Acțiune dacă inspecția de calitate nu este trimisă,
+Auto Insert Price List Rate If Missing,Introduceți automat prețul listei de prețuri dacă lipsește,
+Automatically Set Serial Nos Based on FIFO,Setați automat numărul de serie pe baza FIFO,
+Set Qty in Transactions Based on Serial No Input,Setați cantitatea în tranzacțiile bazate pe intrare de serie,
+Raise Material Request When Stock Reaches Re-order Level,Creșteți cererea de material atunci când stocul atinge nivelul de re-comandă,
+Notify by Email on Creation of Automatic Material Request,Notificați prin e-mail la crearea cererii automate de materiale,
+Allow Material Transfer from Delivery Note to Sales Invoice,Permiteți transferul de materiale din nota de livrare către factura de vânzare,
+Allow Material Transfer from Purchase Receipt to Purchase Invoice,Permiteți transferul de materiale de la chitanța de cumpărare la factura de cumpărare,
+Freeze Stocks Older Than (Days),Înghețați stocurile mai vechi de (zile),
+Role Allowed to Edit Frozen Stock,Rolul permis pentru editarea stocului înghețat,
+The unallocated amount of Payment Entry {0} is greater than the Bank Transaction's unallocated amount,Valoarea nealocată a intrării de plată {0} este mai mare decât suma nealocată a tranzacției bancare,
+Payment Received,Plata primita,
+Attendance cannot be marked outside of Academic Year {0},Prezența nu poate fi marcată în afara anului academic {0},
+Student is already enrolled via Course Enrollment {0},Studentul este deja înscris prin Înscrierea la curs {0},
+Attendance cannot be marked for future dates.,Prezența nu poate fi marcată pentru datele viitoare.,
+Please add programs to enable admission application.,Vă rugăm să adăugați programe pentru a activa cererea de admitere.,
+The following employees are currently still reporting to {0}:,"În prezent, următorii angajați raportează încă la {0}:",
+Please make sure the employees above report to another Active employee.,Vă rugăm să vă asigurați că angajații de mai sus raportează unui alt angajat activ.,
+Cannot Relieve Employee,Nu poate scuti angajatul,
+Please enter {0},Vă rugăm să introduceți {0},
+Please select another payment method. Mpesa does not support transactions in currency '{0}',Vă rugăm să selectați o altă metodă de plată. Mpesa nu acceptă tranzacții în moneda „{0}”,
+Transaction Error,Eroare de tranzacție,
+Mpesa Express Transaction Error,Eroare tranzacție Mpesa Express,
+"Issue detected with Mpesa configuration, check the error logs for more details","Problemă detectată la configurația Mpesa, verificați jurnalele de erori pentru mai multe detalii",
+Mpesa Express Error,Eroare Mpesa Express,
+Account Balance Processing Error,Eroare procesare sold sold,
+Please check your configuration and try again,Vă rugăm să verificați configurația și să încercați din nou,
+Mpesa Account Balance Processing Error,Eroare de procesare a soldului contului Mpesa,
+Balance Details,Detalii sold,
+Current Balance,Sold curent,
+Available Balance,Sold disponibil,
+Reserved Balance,Sold rezervat,
+Uncleared Balance,Sold neclar,
+Payment related to {0} is not completed,Plata aferentă {0} nu este finalizată,
+Row #{}: Item Code: {} is not available under warehouse {}.,Rândul # {}: Codul articolului: {} nu este disponibil în depozit {}.,
+Row #{}: Stock quantity not enough for Item Code: {} under warehouse {}. Available quantity {}.,Rândul # {}: cantitatea de stoc nu este suficientă pentru codul articolului: {} în depozit {}. Cantitate Disponibilă {}.,
+Row #{}: Please select a serial no and batch against item: {} or remove it to complete transaction.,Rândul # {}: selectați un număr de serie și împărțiți-l cu elementul: {} sau eliminați-l pentru a finaliza tranzacția.,
+Row #{}: No serial number selected against item: {}. Please select one or remove it to complete transaction.,Rândul # {}: nu a fost selectat niciun număr de serie pentru elementul: {}. Vă rugăm să selectați una sau să o eliminați pentru a finaliza tranzacția.,
+Row #{}: No batch selected against item: {}. Please select a batch or remove it to complete transaction.,Rândul # {}: nu a fost selectat niciun lot pentru elementul: {}. Vă rugăm să selectați un lot sau să îl eliminați pentru a finaliza tranzacția.,
+Payment amount cannot be less than or equal to 0,Suma plății nu poate fi mai mică sau egală cu 0,
+Please enter the phone number first,Vă rugăm să introduceți mai întâi numărul de telefon,
+Row #{}: {} {} does not exist.,Rândul # {}: {} {} nu există.,
+Row #{0}: {1} is required to create the Opening {2} Invoices,Rândul # {0}: {1} este necesar pentru a crea facturile de deschidere {2},
+You had {} errors while creating opening invoices. Check {} for more details,Ați avut {} erori la crearea facturilor de deschidere. Verificați {} pentru mai multe detalii,
+Error Occured,A aparut o eroare,
+Opening Invoice Creation In Progress,Se deschide crearea facturii în curs,
+Creating {} out of {} {},Se creează {} din {} {},
+(Serial No: {0}) cannot be consumed as it's reserverd to fullfill Sales Order {1}.,(Nr. De serie: {0}) nu poate fi consumat deoarece este rezervat pentru a îndeplini comanda de vânzare {1}.,
+Item {0} {1},Element {0} {1},
+Last Stock Transaction for item {0} under warehouse {1} was on {2}.,Ultima tranzacție de stoc pentru articolul {0} aflat în depozit {1} a fost pe {2}.,
+Stock Transactions for Item {0} under warehouse {1} cannot be posted before this time.,Tranzacțiile de stoc pentru articolul {0} aflat în depozit {1} nu pot fi înregistrate înainte de această dată.,
+Posting future stock transactions are not allowed due to Immutable Ledger,Înregistrarea tranzacțiilor viitoare cu acțiuni nu este permisă din cauza contabilității imuabile,
+A BOM with name {0} already exists for item {1}.,O listă cu numele {0} există deja pentru articolul {1}.,
+{0}{1} Did you rename the item? Please contact Administrator / Tech support,{0} {1} Ați redenumit articolul? Vă rugăm să contactați administratorul / asistența tehnică,
+At row #{0}: the sequence id {1} cannot be less than previous row sequence id {2},La rândul # {0}: ID-ul secvenței {1} nu poate fi mai mic decât ID-ul anterior al secvenței de rând {2},
+The {0} ({1}) must be equal to {2} ({3}),{0} ({1}) trebuie să fie egal cu {2} ({3}),
+"{0}, complete the operation {1} before the operation {2}.","{0}, finalizați operația {1} înainte de operație {2}.",
+Cannot ensure delivery by Serial No as Item {0} is added with and without Ensure Delivery by Serial No.,Nu se poate asigura livrarea prin numărul de serie deoarece articolul {0} este adăugat cu și fără Asigurați livrarea prin numărul de serie,
+Item {0} has no Serial No. Only serilialized items can have delivery based on Serial No,Articolul {0} nu are nr. De serie. Numai articolele serializate pot fi livrate pe baza numărului de serie,
+No active BOM found for item {0}. Delivery by Serial No cannot be ensured,Nu s-a găsit niciun material activ pentru articolul {0}. Livrarea prin nr. De serie nu poate fi asigurată,
+No pending medication orders found for selected criteria,Nu s-au găsit comenzi de medicamente în așteptare pentru criteriile selectate,
+From Date cannot be after the current date.,From Date nu poate fi după data curentă.,
+To Date cannot be after the current date.,To Date nu poate fi după data curentă.,
+From Time cannot be after the current time.,From Time nu poate fi după ora curentă.,
+To Time cannot be after the current time.,To Time nu poate fi după ora curentă.,
+Stock Entry {0} created and ,Înregistrare stoc {0} creată și,
+Inpatient Medication Orders updated successfully,Comenzile pentru medicamente internate au fost actualizate cu succes,
+Row {0}: Cannot create Inpatient Medication Entry against cancelled Inpatient Medication Order {1},Rândul {0}: Nu se poate crea o intrare pentru medicamentul internat împotriva comenzii anulate pentru medicamentul internat {1},
+Row {0}: This Medication Order is already marked as completed,Rândul {0}: această comandă de medicamente este deja marcată ca finalizată,
+Quantity not available for {0} in warehouse {1},Cantitatea nu este disponibilă pentru {0} în depozit {1},
+Please enable Allow Negative Stock in Stock Settings or create Stock Entry to proceed.,Vă rugăm să activați Permiteți stocul negativ în setările stocului sau creați intrarea stocului pentru a continua.,
+No Inpatient Record found against patient {0},Nu s-a găsit nicio înregistrare a pacientului internat împotriva pacientului {0},
+An Inpatient Medication Order {0} against Patient Encounter {1} already exists.,Există deja un ordin de medicare internă {0} împotriva întâlnirii pacientului {1}.,
+Allow In Returns,Permiteți returnări,
+Hide Unavailable Items,Ascundeți articolele indisponibile,
+Apply Discount on Discounted Rate,Aplicați reducere la tariful redus,
+Therapy Plan Template,Șablon de plan de terapie,
+Fetching Template Details,Preluarea detaliilor șablonului,
+Linked Item Details,Detalii legate de articol,
+Therapy Types,Tipuri de terapie,
+Therapy Plan Template Detail,Detaliu șablon plan de terapie,
+Non Conformance,Non conformist,
+Process Owner,Deținătorul procesului,
+Corrective Action,Acțiune corectivă,
+Preventive Action,Actiune preventiva,
+Problem,Problemă,
+Responsible,Responsabil,
+Completion By,Finalizare de,
+Process Owner Full Name,Numele complet al proprietarului procesului,
+Right Index,Index corect,
+Left Index,Index stânga,
+Sub Procedure,Sub procedură,
+Passed,A trecut,
+Print Receipt,Tipărire chitanță,
+Edit Receipt,Editați chitanța,
+Focus on search input,Concentrați-vă pe introducerea căutării,
+Focus on Item Group filter,Concentrați-vă pe filtrul Grup de articole,
+Checkout Order / Submit Order / New Order,Comanda de comandă / Trimiteți comanda / Comanda nouă,
+Add Order Discount,Adăugați reducere la comandă,
+Item Code: {0} is not available under warehouse {1}.,Cod articol: {0} nu este disponibil în depozit {1}.,
+Serial numbers unavailable for Item {0} under warehouse {1}. Please try changing warehouse.,Numerele de serie nu sunt disponibile pentru articolul {0} aflat în depozit {1}. Vă rugăm să încercați să schimbați depozitul.,
+Fetched only {0} available serial numbers.,S-au preluat numai {0} numere de serie disponibile.,
+Switch Between Payment Modes,Comutați între modurile de plată,
+Enter {0} amount.,Introduceți suma {0}.,
+You don't have enough points to redeem.,Nu aveți suficiente puncte de valorificat.,
+You can redeem upto {0}.,Puteți valorifica până la {0}.,
+Enter amount to be redeemed.,Introduceți suma de răscumpărat.,
+You cannot redeem more than {0}.,Nu puteți valorifica mai mult de {0}.,
+Open Form View,Deschideți vizualizarea formularului,
+POS invoice {0} created succesfully,Factura POS {0} a fost creată cu succes,
+Stock quantity not enough for Item Code: {0} under warehouse {1}. Available quantity {2}.,Cantitatea de stoc nu este suficientă pentru Codul articolului: {0} în depozit {1}. Cantitatea disponibilă {2}.,
+Serial No: {0} has already been transacted into another POS Invoice.,Nr. De serie: {0} a fost deja tranzacționat într-o altă factură POS.,
+Balance Serial No,Nr,
+Warehouse: {0} does not belong to {1},Depozit: {0} nu aparține {1},
+Please select batches for batched item {0},Vă rugăm să selectați loturile pentru elementul lot {0},
+Please select quantity on row {0},Vă rugăm să selectați cantitatea de pe rândul {0},
+Please enter serial numbers for serialized item {0},Introduceți numerele de serie pentru articolul serializat {0},
+Batch {0} already selected.,Lotul {0} deja selectat.,
+Please select a warehouse to get available quantities,Vă rugăm să selectați un depozit pentru a obține cantitățile disponibile,
+"For transfer from source, selected quantity cannot be greater than available quantity","Pentru transfer din sursă, cantitatea selectată nu poate fi mai mare decât cantitatea disponibilă",
+Cannot find Item with this Barcode,Nu se poate găsi un articol cu acest cod de bare,
+{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2},{0} este obligatoriu. Poate că înregistrarea schimbului valutar nu este creată pentru {1} până la {2},
+{} has submitted assets linked to it. You need to cancel the assets to create purchase return.,{} a trimis materiale legate de acesta. Trebuie să anulați activele pentru a crea returnarea achiziției.,
+Cannot cancel this document as it is linked with submitted asset {0}. Please cancel it to continue.,Nu se poate anula acest document deoarece este asociat cu materialul trimis {0}. Anulați-l pentru a continua.,
+Row #{}: Serial No. {} has already been transacted into another POS Invoice. Please select valid serial no.,Rândul # {}: numărul de serie {} a fost deja tranzacționat într-o altă factură POS. Vă rugăm să selectați numărul de serie valid.,
+Row #{}: Serial Nos. {} has already been transacted into another POS Invoice. Please select valid serial no.,Rândul # {}: Nr. De serie {} a fost deja tranzacționat într-o altă factură POS. Vă rugăm să selectați numărul de serie valid.,
+Item Unavailable,Elementul nu este disponibil,
+Row #{}: Serial No {} cannot be returned since it was not transacted in original invoice {},Rândul # {}: seria nr. {} Nu poate fi returnată deoarece nu a fost tranzacționată în factura originală {},
+Please set default Cash or Bank account in Mode of Payment {},Vă rugăm să setați implicit numerar sau cont bancar în modul de plată {},
+Please set default Cash or Bank account in Mode of Payments {},Vă rugăm să setați implicit numerar sau cont bancar în modul de plăți {},
+Please ensure {} account is a Balance Sheet account. You can change the parent account to a Balance Sheet account or select a different account.,Vă rugăm să vă asigurați că {} contul este un cont de bilanț. Puteți schimba contul părinte într-un cont de bilanț sau puteți selecta un alt cont.,
+Please ensure {} account is a Payable account. Change the account type to Payable or select a different account.,Vă rugăm să vă asigurați că {} contul este un cont de plătit. Schimbați tipul de cont la Plătibil sau selectați un alt cont.,
+Row {}: Expense Head changed to {} ,Rând {}: capul cheltuielilor a fost schimbat în {},
+because account {} is not linked to warehouse {} ,deoarece contul {} nu este conectat la depozit {},
+or it is not the default inventory account,sau nu este contul de inventar implicit,
+Expense Head Changed,Capul cheltuielilor s-a schimbat,
+because expense is booked against this account in Purchase Receipt {},deoarece cheltuielile sunt rezervate pentru acest cont în chitanța de cumpărare {},
+as no Purchase Receipt is created against Item {}. ,deoarece nu se creează chitanță de cumpărare împotriva articolului {}.,
+This is done to handle accounting for cases when Purchase Receipt is created after Purchase Invoice,Acest lucru se face pentru a gestiona contabilitatea cazurilor în care Bonul de cumpărare este creat după factura de achiziție,
+Purchase Order Required for item {},Comandă de achiziție necesară pentru articolul {},
+To submit the invoice without purchase order please set {} ,"Pentru a trimite factura fără comandă de cumpărare, setați {}",
+as {} in {},ca în {},
+Mandatory Purchase Order,Comandă de cumpărare obligatorie,
+Purchase Receipt Required for item {},Chitanță de cumpărare necesară pentru articolul {},
+To submit the invoice without purchase receipt please set {} ,"Pentru a trimite factura fără chitanță de cumpărare, setați {}",
+Mandatory Purchase Receipt,Chitanță de cumpărare obligatorie,
+POS Profile {} does not belongs to company {},Profilul POS {} nu aparține companiei {},
+User {} is disabled. Please select valid user/cashier,Utilizatorul {} este dezactivat. Vă rugăm să selectați un utilizator / casier valid,
+Row #{}: Original Invoice {} of return invoice {} is {}. ,Rândul # {}: factura originală {} a facturii de returnare {} este {}.,
+Original invoice should be consolidated before or along with the return invoice.,Factura originală ar trebui consolidată înainte sau împreună cu factura de returnare.,
+You can add original invoice {} manually to proceed.,Puteți adăuga factura originală {} manual pentru a continua.,
+Please ensure {} account is a Balance Sheet account. ,Vă rugăm să vă asigurați că {} contul este un cont de bilanț.,
+You can change the parent account to a Balance Sheet account or select a different account.,Puteți schimba contul părinte într-un cont de bilanț sau puteți selecta un alt cont.,
+Please ensure {} account is a Receivable account. ,Vă rugăm să vă asigurați că {} contul este un cont de încasat.,
+Change the account type to Receivable or select a different account.,Schimbați tipul de cont pentru de primit sau selectați un alt cont.,
+{} can't be cancelled since the Loyalty Points earned has been redeemed. First cancel the {} No {},"{} nu poate fi anulat, deoarece punctele de loialitate câștigate au fost valorificate. Anulați mai întâi {} Nu {}",
+already exists,deja exista,
+POS Closing Entry {} against {} between selected period,Închidere POS {} contra {} între perioada selectată,
+POS Invoice is {},Factura POS este {},
+POS Profile doesn't matches {},Profilul POS nu se potrivește cu {},
+POS Invoice is not {},Factura POS nu este {},
+POS Invoice isn't created by user {},Factura POS nu este creată de utilizator {},
+Row #{}: {},Rând #{}: {},
+Invalid POS Invoices,Facturi POS nevalide,
+Please add the account to root level Company - {},Vă rugăm să adăugați contul la compania la nivel de rădăcină - {},
+"While creating account for Child Company {0}, parent account {1} not found. Please create the parent account in corresponding COA","În timp ce creați un cont pentru Compania copil {0}, contul părinte {1} nu a fost găsit. Vă rugăm să creați contul părinte în COA corespunzător",
+Account Not Found,Contul nu a fost găsit,
+"While creating account for Child Company {0}, parent account {1} found as a ledger account.","În timp ce creați un cont pentru Compania pentru copii {0}, contul părinte {1} a fost găsit ca un cont mare.",
+Please convert the parent account in corresponding child company to a group account.,Vă rugăm să convertiți contul părinte al companiei copil corespunzătoare într-un cont de grup.,
+Invalid Parent Account,Cont părinte nevalid,
+"Renaming it is only allowed via parent company {0}, to avoid mismatch.","Redenumirea acestuia este permisă numai prin intermediul companiei-mamă {0}, pentru a evita nepotrivirea.",
+"If you {0} {1} quantities of the item {2}, the scheme {3} will be applied on the item.","Dacă {0} {1} cantitățile articolului {2}, schema {3} va fi aplicată articolului.",
+"If you {0} {1} worth item {2}, the scheme {3} will be applied on the item.","Dacă {0} {1} valorează articolul {2}, schema {3} va fi aplicată articolului.",
+"As the field {0} is enabled, the field {1} is mandatory.","Deoarece câmpul {0} este activat, câmpul {1} este obligatoriu.",
+"As the field {0} is enabled, the value of the field {1} should be more than 1.","Deoarece câmpul {0} este activat, valoarea câmpului {1} trebuie să fie mai mare de 1.",
+Cannot deliver Serial No {0} of item {1} as it is reserved to fullfill Sales Order {2},Nu se poate livra numărul de serie {0} al articolului {1} deoarece este rezervat pentru a îndeplini comanda de vânzare {2},
+"Sales Order {0} has reservation for the item {1}, you can only deliver reserved {1} against {0}.","Comanda de vânzări {0} are rezervare pentru articolul {1}, puteți livra rezervat {1} numai cu {0}.",
+{0} Serial No {1} cannot be delivered,{0} Numărul de serie {1} nu poate fi livrat,
+Row {0}: Subcontracted Item is mandatory for the raw material {1},Rândul {0}: articolul subcontractat este obligatoriu pentru materia primă {1},
+"As there are sufficient raw materials, Material Request is not required for Warehouse {0}.","Deoarece există suficiente materii prime, cererea de material nu este necesară pentru depozit {0}.",
+" If you still want to proceed, please enable {0}.","Dacă totuși doriți să continuați, activați {0}.",
+The item referenced by {0} - {1} is already invoiced,Elementul la care face referire {0} - {1} este deja facturat,
+Therapy Session overlaps with {0},Sesiunea de terapie se suprapune cu {0},
+Therapy Sessions Overlapping,Sesiunile de terapie se suprapun,
+Therapy Plans,Planuri de terapie,
+"Item Code, warehouse, quantity are required on row {0}","Codul articolului, depozitul, cantitatea sunt necesare pe rândul {0}",
+Get Items from Material Requests against this Supplier,Obțineți articole din solicitările materiale împotriva acestui furnizor,
+Enable European Access,Activați accesul european,
+Creating Purchase Order ...,Se creează comanda de cumpărare ...,
+"Select a Supplier from the Default Suppliers of the items below. On selection, a Purchase Order will be made against items belonging to the selected Supplier only.","Selectați un furnizor din furnizorii prestabiliți ai articolelor de mai jos. La selectare, o comandă de achiziție va fi făcută numai pentru articolele aparținând furnizorului selectat.",
+Row #{}: You must select {} serial numbers for item {}.,Rândul # {}: trebuie să selectați {} numere de serie pentru articol {}.,
diff --git a/erpnext/translations/sr-SP.csv b/erpnext/translations/sr-SP.csv
index 27ac944..b14e6d8 100644
--- a/erpnext/translations/sr-SP.csv
+++ b/erpnext/translations/sr-SP.csv
@@ -1,1001 +1,1001 @@
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +153,'Opening','Početno stanje'
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Prosjek dnevne isporuke
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +37,Make Payment Entry,Kreirajte uplatu
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61,Import Failed!,Uvoz nije uspio!
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +46,Warehouse {0} can not be deleted as quantity exists for Item {1},Skladište {0} ne može biti obrisano dok postoji zaliha za artikal {1}
-DocType: Item,Is Purchase Item,Artikal je za poručivanje
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0} does not exist,Skladište {0} ne postoji
-apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Potvrđene porudžbine od strane kupaca
-apps/erpnext/erpnext/public/js/setup_wizard.js +31,Healthcare (beta),Klinika (beta)
-DocType: Salary Slip,Salary Structure,Структура плата
-DocType: Item Reorder,Item Reorder,Dopuna artikla
-apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Prijavi grešku
-DocType: Salary Slip,Net Pay,Neto plaćanje
-DocType: Payment Entry,Internal Transfer,Interni prenos
-DocType: Purchase Invoice Item,Item Tax Rate,Poreska stopa
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1548,Create a new Customer,Kreirajte novog kupca
-DocType: Item Variant Attribute,Attribute,Atribut
-DocType: POS Profile,POS Profile,POS profil
-DocType: Pricing Rule,Min Qty,Min količina
-DocType: Purchase Invoice,Currency and Price List,Valuta i cjenovnik
-DocType: POS Profile,Write Off Account,Otpisati nalog
-DocType: Stock Entry,Delivery Note No,Broj otpremnice
-DocType: Item,Serial Nos and Batches,Serijski brojevi i paketi
-DocType: HR Settings,Employee Records to be created by,Izvještaje o Zaposlenima će kreirati
-DocType: Activity Cost,Projects User,Projektni korisnik
-DocType: Lead,Address Desc,Opis adrese
-DocType: Bank Statement Transaction Payment Item,Mode of Payment,Način plaćanja
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +32,Balance (Dr - Cr),Saldo (Du - Po)
-apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Moja korpa
-DocType: Payment Entry,Payment From / To,Plaćanje od / za
-DocType: Purchase Invoice,Grand Total (Company Currency),Za plaćanje (Valuta preduzeća)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +357,Insufficient Stock,Nedovoljna količina
-DocType: Purchase Invoice,Shipping Rule,Pravila nabavke
-apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Bruto dobit / gubitak
-apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,Pritisnite na artikal da bi ga dodali ovdje
-,Sales Order Trends,Trendovi prodajnih naloga
-DocType: Sales Invoice,Offline POS Name,POS naziv  u režimu van mreže (offline)
-apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +38,You can only renew if your membership expires within 30 days,Можете обновити само ако ваше чланство истиче за мање од 30 дана
-DocType: Request for Quotation Item,Project Name,Naziv Projekta
-apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js +14,Material Transfer,Prenos robe
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +555,Change POS Profile,Promijenite POS korisnika
-apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Napravi predračun
-DocType: Bank Guarantee,Customer,Kupac
-DocType: Purchase Order Item,Supplier Quotation Item,Stavka na dobavljačevoj ponudi
-DocType: Item Group,General Settings,Opšta podešavanja
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +15,Ageing Based On,Staros bazirana na
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Poručeno
-DocType: Email Digest,Credit Balance,Stanje kredita
-apps/erpnext/erpnext/utilities/user_progress.py +147,Gram,Gram
-DocType: Bank Statement Transaction Invoice Item,Purchase Invoice,Faktura nabavke
-DocType: Period Closing Voucher,Closing Fiscal Year,Zatvaranje fiskalne godine
-apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18,You can only select a maximum of one option from the list of check boxes.,Из листе поља за потврду можете изабрати највише једну опцију.
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +56,Group by Voucher,Grupiši po knjiženjima
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +10,Total Outstanding,Ukupno preostalo
-DocType: HR Settings,Email Salary Slip to Employee,Pošalji platnu listu Zaposlenom
-DocType: Item,Customer Code,Šifra kupca
-DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Dozvolite više prodajnih naloga koji su vezani sa porudžbenicom kupca
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,Ukupno isporučeno
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +166,User {0} is already assigned to Employee {1},Korisnik {0} je već označen kao Zaposleni {1}
-,Sales Register,Pregled Prodaje
-DocType: Sales Order,%  Delivered,% Isporučeno
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,Procjena {0} kreirana za Zaposlenog {1} za dati period
-DocType: Journal Entry Account,Party Balance,Stanje kupca
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +73,{0} already allocated for Employee {1} for period {2} to {3},{0} već dodijeljeno zaposlenom {1} za period {2} {3}
-apps/erpnext/erpnext/config/selling.py +23,Customers,Kupci
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +218,Please set User ID field in an Employee record to set Employee Role,Molimo podesite polje Korisnički ID u evidenciji Zaposlenih radi podešavanja zaduženja Zaposlenih
-DocType: Project,Task Completion,Završenost zadataka
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +184,Set as Lost,Obilježi kao izgubljenu
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,Kupovina
-apps/erpnext/erpnext/accounts/party.py +429,{0} {1} is not active,{0} {1} nije aktivan
-DocType: Bin,Reserved Quantity,Rezervisana količina
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +866,Return / Credit Note,Povraćaj / knjižno odobrenje
-DocType: SMS Center,All Employee (Active),Svi zaposleni (aktivni)
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +997,Get Items from BOM,Dodaj stavke iz  БОМ
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2052,Please select customer,Odaberite kupca
-apps/erpnext/erpnext/public/js/templates/address_list.html +22,New Address,Nova adresa
-,Stock Summary,Pregled zalihe
-DocType: Appraisal,For Employee Name,Za ime Zaposlenog
-DocType: Purchase Invoice Item,Net Rate (Company Currency),Neto cijena sa rabatom (Valuta preduzeća)
-DocType: Stock Entry Detail,Additional Cost,Dodatni trošak
-,Purchase Invoice Trends,Trendovi faktura dobavljaća
-DocType: Item Price,Item Price,Cijena artikla
-DocType: Production Plan Sales Order,Sales Order Date,Datum prodajnog naloga
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,Delivery Note {0} must not be submitted,Otpremnica {0} se ne može potvrditi
-apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} status je {2}
-DocType: BOM,Item Image (if not slideshow),Slika artikla (ako nije prezentacija)
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +372,Amount {0} {1} transferred from {2} to {3},Iznos {0} {1} prebačen iz {2} u {3}
-apps/erpnext/erpnext/stock/doctype/item/item.py +304," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Zadrži Uzorak je zasnovano na serijama, molimo označite Ima Broj Serije da bi zadržali uzorak stavke."
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,Pregledi
-DocType: Territory,Classification of Customers by region,Klasifikacija kupaca po regiji
-DocType: Quotation,Quotation To,Ponuda za
-DocType: Payroll Employee Detail,Payroll Employee Detail,Detalji o platnom spisku Zaposlenih
-apps/erpnext/erpnext/config/projects.py +46,Timesheet for tasks.,Potrošeno vrijeme za zadatke
-DocType: Journal Entry,Remark,Napomena
-apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Stablo Vrste artikala
-DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,Korisnici koji konkretnom Zaposlenom mogu odobriti odsustvo
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +142,Accounts Receivable Summary,Pregled potraživanja od kupaca
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Iz otpremnice
-DocType: Account,Tax,Porez
-DocType: Bank Reconciliation,Account Currency,Valuta računa
-DocType: Purchase Invoice,Y,Y
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70,Open Projects,Otvoreni projekti
-DocType: POS Profile,Price List,Cjenovnik
-DocType: Purchase Invoice Item,Rate (Company Currency),Cijena sa rabatom (Valuta preduzeća)
-DocType: Activity Cost,Projects,Projekti
-DocType: Purchase Invoice,Supplier Name,Naziv dobavljača
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +256,Closing (Opening + Total),Ukupno (P.S + promet u periodu)
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +778,Supplier Invoice Date cannot be greater than Posting Date,Datum fakture dobavljača ne može biti veći od datuma otvaranja fakture
-DocType: Production Plan,Sales Orders,Prodajni nalozi
-DocType: Item,Manufacturer Part Number,Proizvođačka šifra
-DocType: Sales Invoice Item,Discount and Margin,Popust i marža
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +68,Avg. Buying Rate,Prosječna vrijednost nabavke
-DocType: Sales Order Item,Gross Profit,Bruto dobit
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +51,Group by Account,Grupiši po računu.
-DocType: Opening Invoice Creation Tool Item,Item Name,Naziv artikla
-DocType: Salary Structure Employee,Salary Structure Employee,Struktura plata Zaposlenih
-DocType: Item,Will also apply for variants,Biće primijenjena i na varijante
-DocType: Purchase Invoice,Total Advance,Ukupno Avans
-apps/erpnext/erpnext/config/selling.py +327,Sales Order to Payment,Prodajni nalog za plaćanje
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +243,Serial No {0} does not belong to any Warehouse,Serijski broj {0} ne pripada ni jednom skladištu
-,Sales Analytics,Prodajna analitika
-apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +26,`Freeze Stocks Older Than` should be smaller than %d days.,"""Zamrzni akcije starije"" trebalo bi da budu manje %d dana."
-DocType: Patient Appointment,Patient Age,Starost pacijenta
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +171,Employee cannot report to himself.,Zaposleni ne može izvještavati sebi
-apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py +24,You can only submit Leave Encashment for a valid encashment amount,Можете поднети Исплату одсуства само са валидном количином за исплату.
-DocType: Sales Invoice,Customer Address,Adresa kupca
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1557,Total Amount {0},Ukupan iznos {0}
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +70,Total (Credit),Ukupno bez PDV-a (duguje)
-DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,Slovima (izvoz) će biti vidljiv onda kad sačuvate otpremnicu
-DocType: Opportunity,Opportunity Date,Datum prilike
-DocType: Employee Attendance Tool,Marked Attendance HTML,Označeno prisustvo HTML
-DocType: Sales Invoice Item,Delivery Note Item,Pozicija otpremnice
-DocType: Sales Invoice,Customer's Purchase Order,Porudžbenica kupca
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +624,Get items from,Dodaj stavke iz
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +36,From {0} to {1},Od {0} do {1}
-DocType: C-Form,Total Invoiced Amount,Ukupno fakturisano
-DocType: Purchase Invoice,Supplier Invoice Date,Datum fakture dobavljača
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +192,Journal Entry {0} does not have account {1} or already matched against other voucher,Knjiženje {0} nema nalog {1} ili je već povezan sa drugim izvodom
-DocType: Lab Test,Lab Test,Lab test
-apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +78,-Above,- Iznad
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +227,{0} {1} is cancelled or stopped,{0} {1} je otkazan ili stopiran
-DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Porezi i naknade dodate (valuta preduzeća)
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,Molimo Vas da unesete ID zaposlenog prodavca
-DocType: Daily Work Summary Settings,"Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.","Email će biti poslat svim Aktivnim Zaposlenima preduzeća u određeno vrijeme, ako nisu na odmoru. Presjek odziva biće poslat u ponoć."
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +386,Note: {0},Bilješka: {0}
-apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},Troškovi aktivnosti zaposlenog {0} na osnovu vrste aktivnosti - {1}
-DocType: Lead,Lost Quotation,Izgubljen Predračun
-DocType: Cash Flow Mapping Accounts,Account,Račun
-DocType: Company,Default Employee Advance Account,Podrazumjevani račun zaposlenog
-apps/erpnext/erpnext/accounts/general_ledger.py +113,Account: {0} can only be updated via Stock Transactions,Računovodstvo: {0} može samo da se ažurira u dijelu Promjene na zalihama
-DocType: Department,Leave Approver,Odobrava izlaske s posla
-DocType: Authorization Rule,Customer or Item,Kupac ili proizvod
-DocType: Upload Attendance,Attendance To Date,Prisustvo do danas
-DocType: Material Request Plan Item,Requested Qty,Tražena kol
-DocType: Education Settings,Attendance Freeze Date,Datum zamrzavanja prisustva
-apps/erpnext/erpnext/stock/get_item_details.py +150,No Item with Serial No {0},Ne postoji artikal sa serijskim brojem {0}
-DocType: POS Profile,Taxes and Charges,Porezi i naknade
-DocType: Item,Serial Number Series,Serijski broj serije
-DocType: Purchase Order,Delivered,Isporučeno
-apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,Zaposleni nije pronađen
-DocType: Selling Settings,Default Territory,Podrazumijevana država
-DocType: Asset,Asset Category,Grupe osnovnih sredstava
-DocType: Sales Invoice Item,Customer Warehouse (Optional),Skladište kupca (opciono)
-DocType: Delivery Note Item,From Warehouse,Iz skladišta
-apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Prikaži zatvorene
-apps/erpnext/erpnext/public/js/utils.js +538,You have already selected items from {0} {1},Већ сте изабрали ставке из {0} {1}
-DocType: Payment Entry,Receive,Prijem
-DocType: Customer,Additional information regarding the customer.,Dodatne informacije o kupcu
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +534,Warehouse required for stock Item {0},Skladište je potrebno unijeti za artikal {0}
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +220,Payment Entry already exists,Uplata već postoji
-DocType: Project,Customer Details,Korisnički detalji
-DocType: Item,"Example: ABCD.#####
+'Opening','Početno stanje'
+Avg Daily Outgoing,Prosjek dnevne isporuke,
+Make Payment Entry,Kreirajte uplatu,
+Import Failed!,Uvoz nije uspio!
+Warehouse {0} can not be deleted as quantity exists for Item {1},Skladište {0} ne može biti obrisano dok postoji zaliha za artikal {1}
+Is Purchase Item,Artikal je za poručivanje,
+Warehouse {0} does not exist,Skladište {0} ne postoji,
+Confirmed orders from Customers.,Potvrđene porudžbine od strane kupaca,
+Healthcare (beta),Klinika (beta)
+Salary Structure,Структура плата
+Item Reorder,Dopuna artikla,
+Report an Issue,Prijavi grešku,
+Net Pay,Neto plaćanje,
+Internal Transfer,Interni prenos,
+Item Tax Rate,Poreska stopa,
+Create a new Customer,Kreirajte novog kupca,
+Attribute,Atribut,
+POS Profile,POS profil,
+Min Qty,Min količina,
+Currency and Price List,Valuta i cjenovnik,
+Write Off Account,Otpisati nalog,
+Delivery Note No,Broj otpremnice,
+Serial Nos and Batches,Serijski brojevi i paketi,
+Employee Records to be created by,Izvještaje o Zaposlenima će kreirati,
+Projects User,Projektni korisnik,
+Address Desc,Opis adrese,
+Mode of Payment,Način plaćanja,
+Balance (Dr - Cr),Saldo (Du - Po)
+My Cart,Moja korpa,
+Payment From / To,Plaćanje od / za,
+Grand Total (Company Currency),Za plaćanje (Valuta preduzeća)
+Insufficient Stock,Nedovoljna količina,
+Shipping Rule,Pravila nabavke,
+Gross Profit / Loss,Bruto dobit / gubitak,
+Tap items to add them here,Pritisnite na artikal da bi ga dodali ovdje,
+Sales Order Trends,Trendovi prodajnih naloga,
+Offline POS Name,POS naziv  u režimu van mreže (offline)
+You can only renew if your membership expires within 30 days,Можете обновити само ако ваше чланство истиче за мање од 30 дана
+Project Name,Naziv Projekta,
+Material Transfer,Prenos robe,
+Change POS Profile,Promijenite POS korisnika,
+Make Quotation,Napravi predračun,
+Customer,Kupac,
+Supplier Quotation Item,Stavka na dobavljačevoj ponudi,
+General Settings,Opšta podešavanja,
+Ageing Based On,Staros bazirana na,
+Ordered,Poručeno,
+Credit Balance,Stanje kredita,
+Gram,Gram,
+Purchase Invoice,Faktura nabavke,
+Closing Fiscal Year,Zatvaranje fiskalne godine,
+You can only select a maximum of one option from the list of check boxes.,Из листе поља за потврду можете изабрати највише једну опцију.
+Group by Voucher,Grupiši po knjiženjima,
+Total Outstanding,Ukupno preostalo,
+Email Salary Slip to Employee,Pošalji platnu listu Zaposlenom,
+Customer Code,Šifra kupca,
+Allow multiple Sales Orders against a Customer's Purchase Order,Dozvolite više prodajnih naloga koji su vezani sa porudžbenicom kupca,
+Total Outgoing,Ukupno isporučeno,
+User {0} is already assigned to Employee {1},Korisnik {0} je već označen kao Zaposleni {1}
+Sales Register,Pregled Prodaje,
+%  Delivered,% Isporučeno,
+Appraisal {0} created for Employee {1} in the given date range,Procjena {0} kreirana za Zaposlenog {1} za dati period,
+Party Balance,Stanje kupca,
+{0} already allocated for Employee {1} for period {2} to {3},{0} već dodijeljeno zaposlenom {1} za period {2} {3}
+Customers,Kupci,
+Please set User ID field in an Employee record to set Employee Role,Molimo podesite polje Korisnički ID u evidenciji Zaposlenih radi podešavanja zaduženja Zaposlenih,
+Task Completion,Završenost zadataka,
+Set as Lost,Obilježi kao izgubljenu,
+Buy,Kupovina,
+{0} {1} is not active,{0} {1} nije aktivan,
+Reserved Quantity,Rezervisana količina,
+Return / Credit Note,Povraćaj / knjižno odobrenje,
+All Employee (Active),Svi zaposleni (aktivni)
+Get Items from BOM,Dodaj stavke iz  БОМ
+Please select customer,Odaberite kupca,
+New Address,Nova adresa,
+Stock Summary,Pregled zalihe,
+For Employee Name,Za ime Zaposlenog,
+Net Rate (Company Currency),Neto cijena sa rabatom (Valuta preduzeća)
+Additional Cost,Dodatni trošak,
+Purchase Invoice Trends,Trendovi faktura dobavljaća,
+Item Price,Cijena artikla,
+Sales Order Date,Datum prodajnog naloga,
+Delivery Note {0} must not be submitted,Otpremnica {0} se ne može potvrditi,
+{0} {1} status is {2},{0} {1} status je {2}
+Item Image (if not slideshow),Slika artikla (ako nije prezentacija)
+Amount {0} {1} transferred from {2} to {3},Iznos {0} {1} prebačen iz {2} u {3}
+" {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Zadrži Uzorak je zasnovano na serijama, molimo označite Ima Broj Serije da bi zadržali uzorak stavke."
+Consultations,Pregledi,
+Classification of Customers by region,Klasifikacija kupaca po regiji,
+Quotation To,Ponuda za,
+Payroll Employee Detail,Detalji o platnom spisku Zaposlenih,
+Timesheet for tasks.,Potrošeno vrijeme za zadatke,
+Remark,Napomena,
+Tree of Item Groups.,Stablo Vrste artikala,
+Users who can approve a specific employee's leave applications,Korisnici koji konkretnom Zaposlenom mogu odobriti odsustvo,
+Accounts Receivable Summary,Pregled potraživanja od kupaca,
+From Delivery Note,Iz otpremnice,
+Tax,Porez,
+Account Currency,Valuta računa,
+Y,Y,
+Open Projects,Otvoreni projekti,
+Price List,Cjenovnik,
+Rate (Company Currency),Cijena sa rabatom (Valuta preduzeća)
+Projects,Projekti,
+Supplier Name,Naziv dobavljača,
+Closing (Opening + Total),Ukupno (P.S + promet u periodu)
+Supplier Invoice Date cannot be greater than Posting Date,Datum fakture dobavljača ne može biti veći od datuma otvaranja fakture,
+Sales Orders,Prodajni nalozi,
+Manufacturer Part Number,Proizvođačka šifra,
+Discount and Margin,Popust i marža,
+Avg. Buying Rate,Prosječna vrijednost nabavke,
+Gross Profit,Bruto dobit,
+Group by Account,Grupiši po računu.
+Item Name,Naziv artikla,
+Salary Structure Employee,Struktura plata Zaposlenih,
+Will also apply for variants,Biće primijenjena i na varijante,
+Total Advance,Ukupno Avans,
+Sales Order to Payment,Prodajni nalog za plaćanje,
+Serial No {0} does not belong to any Warehouse,Serijski broj {0} ne pripada ni jednom skladištu,
+Sales Analytics,Prodajna analitika,
+`Freeze Stocks Older Than` should be smaller than %d days.,"""Zamrzni akcije starije"" trebalo bi da budu manje %d dana."
+Patient Age,Starost pacijenta,
+Employee cannot report to himself.,Zaposleni ne može izvještavati sebi,
+You can only submit Leave Encashment for a valid encashment amount,Можете поднети Исплату одсуства само са валидном количином за исплату.
+Customer Address,Adresa kupca,
+Total Amount {0},Ukupan iznos {0}
+Total (Credit),Ukupno bez PDV-a (duguje)
+In Words (Export) will be visible once you save the Delivery Note.,Slovima (izvoz) će biti vidljiv onda kad sačuvate otpremnicu,
+Opportunity Date,Datum prilike,
+Marked Attendance HTML,Označeno prisustvo HTML,
+Delivery Note Item,Pozicija otpremnice,
+Customer's Purchase Order,Porudžbenica kupca,
+Get items from,Dodaj stavke iz,
+From {0} to {1},Od {0} do {1}
+Total Invoiced Amount,Ukupno fakturisano,
+Supplier Invoice Date,Datum fakture dobavljača,
+Journal Entry {0} does not have account {1} or already matched against other voucher,Knjiženje {0} nema nalog {1} ili je već povezan sa drugim izvodom,
+Lab Test,Lab test,
+-Above,- Iznad,
+{0} {1} is cancelled or stopped,{0} {1} je otkazan ili stopiran,
+Taxes and Charges Added (Company Currency),Porezi i naknade dodate (valuta preduzeća)
+Please enter Employee Id of this sales person,Molimo Vas da unesete ID zaposlenog prodavca,
+"Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.","Email će biti poslat svim Aktivnim Zaposlenima preduzeća u određeno vrijeme, ako nisu na odmoru. Presjek odziva biće poslat u ponoć."
+Note: {0},Bilješka: {0}
+Activity Cost exists for Employee {0} against Activity Type - {1},Troškovi aktivnosti zaposlenog {0} na osnovu vrste aktivnosti - {1}
+Lost Quotation,Izgubljen Predračun,
+Account,Račun,
+Default Employee Advance Account,Podrazumjevani račun zaposlenog,
+Account: {0} can only be updated via Stock Transactions,Računovodstvo: {0} može samo da se ažurira u dijelu Promjene na zalihama,
+Leave Approver,Odobrava izlaske s posla,
+Customer or Item,Kupac ili proizvod,
+Attendance To Date,Prisustvo do danas,
+Requested Qty,Tražena kol,
+Attendance Freeze Date,Datum zamrzavanja prisustva,
+No Item with Serial No {0},Ne postoji artikal sa serijskim brojem {0}
+Taxes and Charges,Porezi i naknade,
+Serial Number Series,Serijski broj serije,
+Delivered,Isporučeno,
+No employee found,Zaposleni nije pronađen,
+Default Territory,Podrazumijevana država,
+Asset Category,Grupe osnovnih sredstava,
+Customer Warehouse (Optional),Skladište kupca (opciono)
+From Warehouse,Iz skladišta,
+Show closed,Prikaži zatvorene,
+You have already selected items from {0} {1},Већ сте изабрали ставке из {0} {1}
+Receive,Prijem,
+Additional information regarding the customer.,Dodatne informacije o kupcu,
+Warehouse required for stock Item {0},Skladište je potrebno unijeti za artikal {0}
+Payment Entry already exists,Uplata već postoji,
+Customer Details,Korisnički detalji,
+"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.","Primjer:. ABCD ##### 
  Ако Радња је смештена i serijski broj se ne pominje u transakcijama, onda će automatski serijski broj biti kreiran na osnovu ove serije. Ukoliko uvijek želite da eksplicitno spomenete serijski broj ove šifre, onda je ostavite praznu."
-apps/erpnext/erpnext/config/selling.py +322,Customer and Supplier,Kupac i dobavljač
-DocType: Project,% Completed,% završen
-DocType: Bank Statement Transaction Invoice Item,Sales Invoice,Faktura prodaje
-DocType: Journal Entry,Accounting Entries,Računovodstveni unosi
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +253,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Red # {0}: Knjiženje {1} nema kreiran nalog {2} ili je već povezan sa drugim izvodom.
-DocType: Purchase Invoice,Print Language,Jezik za štampu
-apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,"""Na osnovu"" и ""Grupiši po"" ne mogu biti identični"
-DocType: Antibiotic,Healthcare Administrator,Administrator klinike
-DocType: Sales Order,Track this Sales Order against any Project,Prati ovaj prodajni nalog na bilo kom projektu
-DocType: Quotation Item,Stock Balance,Pregled trenutne zalihe
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +530,[Error],[Greška]
-DocType: Supplier,Supplier Details,Detalji o dobavljaču
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Forum zajednice
-,Batch Item Expiry Status,Pregled artikala sa rokom trajanja
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +887,Payment,Plaćanje
-,Sales Partners Commission,Provizija za prodajne partnere
-DocType: C-Form Invoice Detail,Territory,Teritorija
-DocType: Notification Control,Sales Order Message,Poruka prodajnog naloga
-DocType: Employee Attendance Tool,Employees HTML,HTML Zaposlenih
-,Employee Leave Balance,Pregled odsustva Zaposlenih
-apps/erpnext/erpnext/utilities/user_progress.py +147,Minute,Minut
-DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,Pošalji platnu listu Zaposlenom na željenu adresu označenu u tab-u ZAPOSLENI
-apps/erpnext/erpnext/utilities/user_progress.py +147,Litre,Litar
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +250,Opening (Cr),Početno stanje (Po)
-DocType: Academic Term,Academics User,Akademski korisnik
-DocType: Student,Blood Group,Krvna grupa
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Izjava o računu
-DocType: Delivery Note,Billing Address,Adresa za naplatu
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +451,All Territories,Sve države
-DocType: Payment Entry,Received Amount (Company Currency),Iznos uplate (Valuta preduzeća)
-DocType: Blanket Order Item,Ordered Quantity,Poručena količina
-DocType: Lab Test Template,Standard Selling Rate,Standarna prodajna cijena
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +58,Total Outstanding: {0},Ukupno preostalo: {0}
-apps/erpnext/erpnext/config/setup.py +116,Human Resources,Ljudski resursi
-DocType: Sales Invoice Item,Rate With Margin,Cijena sa popustom
-DocType: Student Attendance,Student Attendance,Prisustvo učenika
-apps/erpnext/erpnext/utilities/activation.py +108,Add Timesheets,Dodaj potrošeno vrijeme
-apps/erpnext/erpnext/public/js/setup_wizard.js +254,Collapse All,Skupi sve
-apps/erpnext/erpnext/public/js/conf.js +28,User Forum,Korisnički portal
-DocType: Purchase Order Item Supplied,Stock UOM,JM zalihe
-DocType: Fee Validity,Valid Till,Važi do
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1399,Select or add new customer,Izaberite ili dodajte novog kupca
-apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Zaposleni i prisustvo
-apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10,Leave and Attendance,Odsustvo i prisustvo
-,Trial Balance for Party,Struktura dugovanja
-DocType: Program Enrollment Tool,New Program,Novi program
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +603,Taxable Amount,Oporezivi iznos
-DocType: Production Plan Item,Product Bundle Item,Sastavljeni proizvodi
-DocType: Payroll Entry,Select Employees,Odaberite Zaposlene
-apps/erpnext/erpnext/utilities/activation.py +136,"Create Employee records to manage leaves, expense claims and payroll","Kreiraj evidenciju o Zaposlenom kako bi upravljali odsustvom, potraživanjima za troškove i platnim spiskovima"
-apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,Ovo se zasniva na pohađanju ovog zaposlenog
-DocType: Lead,Address & Contact,Adresa i kontakt
-DocType: Bin,Reserved Qty for Production,Rezervisana kol. za proizvodnju
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,Ovo praćenje je zasnovano na kretanje zaliha. Pogledajte {0} za više detalja
-DocType: Training Event Employee,Training Event Employee,Obuke Zaposlenih
-apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Svi kontakti
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Sales Person,Prodajni agent
-DocType: QuickBooks Migrator,Default Warehouse,Podrazumijevano skladište
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,Тренутно не постоје залихе у складишту
-DocType: Company,Default Letter Head,Podrazumijevano zaglavlje
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +84,Sales Order {0} is not valid,Prodajni nalog {0} nije validan
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82,Year start date or end date is overlapping with {0}. To avoid please set company,Датум почетка или краја године се преклапа са {0}.  Да бисте избегли молимо поставите компанију
-DocType: Account,Credit,Potražuje
-DocType: C-Form Invoice Detail,Grand Total,Za plaćanje
-apps/erpnext/erpnext/config/learn.py +229,Human Resource,Ljudski resursi
-DocType: Payroll Entry,Employees,Zaposleni
-DocType: Selling Settings,Delivery Note Required,Otpremnica je obavezna
-DocType: Payment Entry,Type of Payment,Vrsta plaćanja
-DocType: Purchase Invoice Item,UOM,JM
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +66,Difference Amount must be zero,Razlika u iznosu mora biti nula
-DocType: Sales Order,Not Delivered,Nije isporučeno
-apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Prodajne kampanje
-DocType: Item,Auto re-order,Automatska porudžbina
-,Profit and Loss Statement,Bilans uspjeha
-apps/erpnext/erpnext/utilities/user_progress.py +147,Meter,Metar
-apps/erpnext/erpnext/utilities/user_progress.py +146,Pair,Par
-,Profitability Analysis,Analiza profitabilnosti
-DocType: Contract,HR Manager,Menadžer za ljudske resurse
-DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Porez (valuta preduzeća)
-DocType: Asset,Quality Manager,Menadžer za kvalitet
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +280,Sales Invoice {0} has already been submitted,Faktura prodaje {0} je već potvrđena
-DocType: Project Task,Weight,Težina
-DocType: Sales Invoice Timesheet,Timesheet Detail,Detalji potrošenog vremena
-DocType: Delivery Note,Is Return,Da li je povratak
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +891,Material Receipt,Prijem robe
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +800,Supplier Invoice No exists in Purchase Invoice {0},Broj fakture dobavljača već postoji u fakturi nabavke {0}
-DocType: BOM Explosion Item,Source Warehouse,Izvorno skladište
-apps/erpnext/erpnext/config/learn.py +253,Managing Projects,Upravljanje projektima
-apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +26,Pricing,Kalkulacija
-DocType: Supplier,Name and Type,Ime i tip
-DocType: Customs Tariff Number,Customs Tariff Number,Carinska tarifa
-apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +65,"You can claim only an amount of {0}, the rest amount {1} should be in the application \
+Customer and Supplier,Kupac i dobavljač
+% Completed,% završen,
+Sales Invoice,Faktura prodaje,
+Accounting Entries,Računovodstveni unosi,
+Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Red # {0}: Knjiženje {1} nema kreiran nalog {2} ili je već povezan sa drugim izvodom.
+Print Language,Jezik za štampu,
+'Based On' and 'Group By' can not be same,"""Na osnovu"" и ""Grupiši po"" ne mogu biti identični"
+Healthcare Administrator,Administrator klinike,
+Track this Sales Order against any Project,Prati ovaj prodajni nalog na bilo kom projektu,
+Stock Balance,Pregled trenutne zalihe,
+[Error],[Greška]
+Supplier Details,Detalji o dobavljaču,
+Community Forum,Forum zajednice,
+Batch Item Expiry Status,Pregled artikala sa rokom trajanja,
+Payment,Plaćanje,
+Sales Partners Commission,Provizija za prodajne partnere,
+Territory,Teritorija,
+Sales Order Message,Poruka prodajnog naloga,
+Employees HTML,HTML Zaposlenih,
+Employee Leave Balance,Pregled odsustva Zaposlenih,
+Minute,Minut,
+Emails salary slip to employee based on preferred email selected in Employee,Pošalji platnu listu Zaposlenom na željenu adresu označenu u tab-u ZAPOSLENI,
+Litre,Litar,
+Opening (Cr),Početno stanje (Po)
+Academics User,Akademski korisnik,
+Blood Group,Krvna grupa,
+Statement of Account,Izjava o računu,
+Billing Address,Adresa za naplatu,
+All Territories,Sve države,
+Received Amount (Company Currency),Iznos uplate (Valuta preduzeća)
+Ordered Quantity,Poručena količina,
+Standard Selling Rate,Standarna prodajna cijena,
+Total Outstanding: {0},Ukupno preostalo: {0}
+Human Resources,Ljudski resursi,
+Rate With Margin,Cijena sa popustom,
+Student Attendance,Prisustvo učenika,
+Add Timesheets,Dodaj potrošeno vrijeme,
+Collapse All,Skupi sve,
+User Forum,Korisnički portal,
+Stock UOM,JM zalihe,
+Valid Till,Važi do,
+Select or add new customer,Izaberite ili dodajte novog kupca,
+Employee and Attendance,Zaposleni i prisustvo,
+Leave and Attendance,Odsustvo i prisustvo,
+Trial Balance for Party,Struktura dugovanja,
+New Program,Novi program,
+Taxable Amount,Oporezivi iznos,
+Product Bundle Item,Sastavljeni proizvodi,
+Select Employees,Odaberite Zaposlene,
+"Create Employee records to manage leaves, expense claims and payroll","Kreiraj evidenciju o Zaposlenom kako bi upravljali odsustvom, potraživanjima za troškove i platnim spiskovima"
+This is based on the attendance of this Employee,Ovo se zasniva na pohađanju ovog zaposlenog,
+Address & Contact,Adresa i kontakt,
+Reserved Qty for Production,Rezervisana kol. za proizvodnju,
+This is based on stock movement. See {0} for details,Ovo praćenje je zasnovano na kretanje zaliha. Pogledajte {0} za više detalja,
+Training Event Employee,Obuke Zaposlenih,
+All Contacts.,Svi kontakti,
+Sales Person,Prodajni agent,
+Default Warehouse,Podrazumijevano skladište,
+ Currently no stock available in any warehouse,Тренутно не постоје залихе у складишту
+Default Letter Head,Podrazumijevano zaglavlje,
+Sales Order {0} is not valid,Prodajni nalog {0} nije validan,
+Year start date or end date is overlapping with {0}. To avoid please set company,Датум почетка или краја године се преклапа са {0}.  Да бисте избегли молимо поставите компанију
+Credit,Potražuje,
+Grand Total,Za plaćanje,
+Human Resource,Ljudski resursi,
+Employees,Zaposleni,
+Delivery Note Required,Otpremnica je obavezna,
+Type of Payment,Vrsta plaćanja,
+UOM,JM,
+Difference Amount must be zero,Razlika u iznosu mora biti nula,
+Not Delivered,Nije isporučeno,
+Sales campaigns.,Prodajne kampanje,
+Auto re-order,Automatska porudžbina,
+Profit and Loss Statement,Bilans uspjeha,
+Meter,Metar,
+Pair,Par,
+Profitability Analysis,Analiza profitabilnosti,
+HR Manager,Menadžer za ljudske resurse,
+Total Taxes and Charges (Company Currency),Porez (valuta preduzeća)
+Quality Manager,Menadžer za kvalitet,
+Sales Invoice {0} has already been submitted,Faktura prodaje {0} je već potvrđena,
+Weight,Težina,
+Timesheet Detail,Detalji potrošenog vremena,
+Is Return,Da li je povratak,
+Material Receipt,Prijem robe,
+Supplier Invoice No exists in Purchase Invoice {0},Broj fakture dobavljača već postoji u fakturi nabavke {0}
+Source Warehouse,Izvorno skladište,
+Managing Projects,Upravljanje projektima,
+Pricing,Kalkulacija,
+Name and Type,Ime i tip,
+Customs Tariff Number,Carinska tarifa,
+"You can claim only an amount of {0}, the rest amount {1} should be in the application \
 				as pro-rata component","Можете тражити само износ од {0}, остатак од {1} би требао бити у апликацији \ као про-рата компонента."
-DocType: Crop,Yield UOM,Јединица мере приноса
-DocType: Item Default,Default Supplier,Podrazumijevani dobavljač
-apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,Select Patient,Izaberite pacijenta
-apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Opening,Početno stanje
-DocType: POS Profile,Customer Groups,Grupe kupaca
-DocType: Hub Tracked Item,Item Manager,Menadžer artikala
-DocType: Fiscal Year Company,Fiscal Year Company,Fiskalna godina preduzeća
-DocType: Patient Appointment,Patient Appointment,Zakazivanje pacijenata
-DocType: BOM,Show In Website,Prikaži na web sajtu
-DocType: Payment Entry,Paid Amount,Uplaćeno
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +137,Total Paid Amount,Ukupno plaćeno
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +267,Purchase Receipt {0} is not submitted,Prijem robe {0} nije potvrđen
-apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Proizvodi i cijene
-DocType: Payment Entry,Account Paid From,Račun plaćen preko
-apps/erpnext/erpnext/utilities/activation.py +72,Create customer quotes,Kreirajte bilješke kupca
-DocType: Purchase Invoice,Supplier Warehouse,Skladište dobavljača
-apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Kupac je obavezan podatak
-DocType: Item,Manufacturer,Proizvođač
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69,Selling Amount,Prodajni iznos
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +417,Please set the Date Of Joining for employee {0},Molimo podesite datum zasnivanja radnog odnosa {0}
-DocType: Item,Allow over delivery or receipt upto this percent,Dozvolite isporukuili prijem robe ukoliko ne premaši ovaj procenat
-DocType: Shopping Cart Settings,Orders,Porudžbine
-apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Promjene na zalihama
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +183,You are not authorized to approve leaves on Block Dates,Немате дозволу да одобравате одсуства на Блок Датумима.
-,Daily Timesheet Summary,Pregled dnevnog potrošenog vremena
-DocType: Project Task,View Timesheet,Pogledaj potrošeno vrijeme
-DocType: Purchase Invoice,Rounded Total (Company Currency),Zaokruženi ukupan iznos (valuta preduzeća)
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +403,Salary Slip of employee {0} already created for this period,Isplatna lista Zaposlenog {0} kreirana je već za ovaj period
-DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Ako ovaj artikal ima varijante, onda ne može biti biran u prodajnom nalogu."
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1517,You can only redeem max {0} points in this order.,Можете унети највише {0} поена у овој наруџбини.
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +38,No leave record found for employee {0} for {1},Nije nađena evidancija o odsustvu Zaposlenog {0} za {1}
-DocType: Pricing Rule,Discount on Price List Rate (%),Popust na cijene iz cjenovnika (%)
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +17,Groups,Grupe
-DocType: Item,Item Attribute,Atribut artikla
-DocType: Payment Request,Amount in customer's currency,Iznos u valuti kupca
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +105,Warehouse is mandatory,Skladište je obavezan podatak
-,Stock Ageing,Starost zaliha
-DocType: Email Digest,New Sales Orders,Novi prodajni nalozi
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64,Invoice Created,Kreirana faktura
-DocType: Employee Internal Work History,Employee Internal Work History,Interna radna istorija Zaposlenog
-apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25,Cart is Empty,Korpa je prazna
-DocType: Patient,Patient Details,Detalji o pacijentu
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +583,Stock Entry {0} is not submitted,Unos zaliha {0} nije potvrđen
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105,Rest Of The World,Ostatak svijeta
-DocType: Work Order,Additional Operating Cost,Dodatni operativni troškovi
-DocType: Purchase Invoice,Rejected Warehouse,Odbijeno skladište
-DocType: Asset Repair,Manufacturing Manager,Menadžer proizvodnje
-apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +39,You are not present all day(s) between compensatory leave request days,Нисте присутни свих дана између захтева за компензацијски одмор.
-DocType: Purchase Invoice Item,Is Fixed Asset,Artikal je osnovno sredstvo
-,POS,POS
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +367,Timesheet {0} is already completed or cancelled,Potrošeno vrijeme {0} je već potvrđeno ili otkazano
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +526, (Half Day),(Pola dana)
-DocType: Shipping Rule,Net Weight,Neto težina
-apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56,Attendance Record {0} exists against Student {1},Zapis o prisustvu {0} постоји kod studenata {1}
-DocType: Payment Entry Reference,Outstanding,Preostalo
-DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Popust (%)
-DocType: Purchase Invoice,Select Shipping Address,Odaberite adresu isporuke
-apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Iznos za fakturisanje
-apps/erpnext/erpnext/utilities/activation.py +82,Make Sales Orders to help you plan your work and deliver on-time,Kreiranje prodajnog naloga će vam pomoći da isplanirate svoje vrijeme i dostavite robu na vrijeme
-apps/erpnext/erpnext/accounts/page/pos/pos.js +809,Sync Offline Invoices,Sinhronizuj offline fakture
-DocType: Blanket Order,Manufacturing,Proizvodnja
-apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% Isporučeno
-apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,Prisustvo
-DocType: Delivery Note,Customer's Purchase Order No,Broj porudžbenice kupca
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125,Please enter Sales Orders in the above table,U tabelu iznad unesite prodajni nalog
-DocType: Quality Inspection,Report Date,Datum izvještaja
-DocType: POS Profile,Item Groups,Vrste artikala
-DocType: Pricing Rule,Discount Percentage,Procenat popusta
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Gross Profit %,Bruto dobit%
-DocType: Crop,"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Овде можете дефинисати све задатке које је потребно извршити за ову жетву. Поље Дан говори дан на који је задатак потребно извршити, 1 је 1. дан, итд."
-apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js +7,Payment Request,Upit za plaćanje
-,Purchase Analytics,Analiza nabavke
-DocType: Location,Tree Details,Detalji stabla
-DocType: Upload Attendance,Upload Attendance,Priloži evidenciju
-DocType: GL Entry,Against,Povezano sa
-DocType: Grant Application,Requested Amount,Traženi iznos
-apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.","Snimanje svih komunikacija tipa email, telefon, poruke, posjete, itd."
-DocType: Purchase Order,Customer Contact Email,Kontakt e-mail kupca
-apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34,Primary Address Details,Detalji o primarnoj adresi
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +98,Above,Iznad
-DocType: Item,Variant Based On,Varijanta zasnovana na
-DocType: Project,Task Weight,Težina zadataka
-DocType: Payment Entry,Transaction ID,Transakcije
-DocType: Payment Entry Reference,Allocated,Dodijeljeno
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +180,Add more items or open full form,Dodaj još stavki ili otvori kompletan prozor
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49,Reserved for sale,Rezervisana za prodaju
-DocType: POS Item Group,Item Group,Vrste artikala
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +84,Age (Days),Starost (Dani)
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +243,Opening (Dr),Početno stanje (Du)
-apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +50,Total Outstanding Amt,Preostalo za plaćanje
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Idite na radnu površinu i krenite sa radom u programu
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +71,You can only have Plans with the same billing cycle in a Subscription,Сви Планови у Претплати морају имати исти циклус наплате
-DocType: Sales Person,Name and Employee ID,Ime i ID Zaposlenog
-DocType: Bank Statement Transaction Invoice Item,Invoice,Faktura
-DocType: Bank Statement Transaction Invoice Item,Invoice Date,Datum fakture
-DocType: Customer,From Lead,Od Lead-a
-apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,Baza potencijalnih kupaca
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Status Projekta
-apps/erpnext/erpnext/public/js/pos/pos.html +124,All Item Groups,Sve vrste artikala
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,Serijski broj {0} ne postoji
-apps/erpnext/erpnext/public/js/templates/contact_list.html +34,No contacts added yet.,Još uvijek nema dodatih kontakata
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +42,Ageing Range 3,Opseg dospijeća 3
-DocType: Request for Quotation,Request for Quotation,Zahtjev za ponudu
-DocType: Payment Entry,Account Paid To,Račun plaćen u
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +44,Attendance can not be marked for future dates,Učesnik ne može biti označen za buduće datume
-DocType: Stock Entry,Sales Invoice No,Broj fakture prodaje
-apps/erpnext/erpnext/projects/doctype/task/task.js +39,Timesheet,Potrošeno vrijeme
-DocType: HR Settings,Don't send Employee Birthday Reminders,Nemojte slati podsjetnik o rođendanima Zaposlenih
-DocType: Sales Invoice Item,Available Qty at Warehouse,Dostupna količina na skladištu
-DocType: Item,Foreign Trade Details,Spoljnotrgovinski detalji
-DocType: Item,Minimum Order Qty,Minimalna količina za poručivanje
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +68,No employees for the mentioned criteria,Za traženi kriterijum nema Zaposlenih
-DocType: Budget,Fiscal Year,Fiskalna godina
-DocType: Stock Entry,Repack,Prepakovati
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +135,Please select a warehouse,Izaberite skladište
-DocType: Purchase Receipt Item,Received and Accepted,Primio i prihvatio
-DocType: Project,Project will be accessible on the website to these users,Projekat će biti dostupan na sajtu sledećim korisnicima
-DocType: Upload Attendance,Upload HTML,Priloži HTML
-apps/erpnext/erpnext/public/js/setup_wizard.js +29,Services,Usluge
-apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,Korpa sa artiklima
-apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +34,Total Paid Amt,Ukupno plaćeno
-DocType: Warehouse,Warehouse Detail,Detalji o skldištu
-DocType: Quotation Item,Quotation Item,Stavka sa ponude
-DocType: Journal Entry Account,Employee Advance,Napredak Zaposlenog
-DocType: Purchase Order Item,Warehouse and Reference,Skladište i veza
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +93,{0} {1}: Account {2} is inactive,{0} {1}: Nalog {2} je neaktivan
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +467,Fiscal Year {0} not found,Fiskalna godina {0} nije pronađena
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +121,No Remarks,Nema napomene
-DocType: Notification Control,Purchase Receipt Message,Poruka u Prijemu robe
-DocType: Purchase Invoice,Taxes and Charges Deducted,Umanjeni porezi i naknade
-DocType: Sales Invoice,Include Payment (POS),Uključi POS plaćanje
-DocType: Sales Invoice,Customer PO Details,Pregled porudžbine kupca
-apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +27,Total Invoiced Amt,Ukupno fakturisano
-apps/erpnext/erpnext/public/js/stock_analytics.js +54,Select Brand...,Izaberite brend
-DocType: Item,Default Unit of Measure,Podrazumijevana jedinica mjere
-DocType: Purchase Invoice Item,Serial No,Serijski broj
-DocType: Supplier,Supplier Type,Tip dobavljača
-apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Trenutna kol. {0} / Na čekanju {1}
-DocType: Supplier,Individual,Fizičko lice
-apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9,Partially Ordered,Djelimično poručeno
-DocType: Bank Reconciliation Detail,Posting Date,Datum dokumenta
-DocType: Cheque Print Template,Date Settings,Podešavanje datuma
-DocType: Payment Entry,Total Allocated Amount (Company Currency),Ukupan povezani iznos (Valuta)
-DocType: Account,Income,Prihod
-apps/erpnext/erpnext/public/js/utils/item_selector.js +20,Add Items,Dodaj stavke
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1731,Price List not found or disabled,Cjenovnik nije pronađen ili je zaključan
-DocType: Vital Signs,Weight (In Kilogram),Težina (u kg)
-apps/erpnext/erpnext/accounts/page/pos/pos.js +796,New Sales Invoice,Nova faktura
-DocType: Employee Transfer,New Company,Novo preduzeće
-DocType: Issue,Support Team,Tim za podršku
-DocType: Item,Valuation Method,Način vrednovanja
-DocType: Project,Project Type,Tip Projekta
-DocType: Purchase Order Item,Returned Qty,Vraćena kol.
-DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Iznos dodatnog popusta (valuta preduzeća)
-,Employee Information,Informacije o Zaposlenom
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,"""Dana od poslednje porudžbine"" mora biti veće ili jednako nuli"
-DocType: Asset,Maintenance,Održavanje
-DocType: Item Price,Multiple Item prices.,Više cijena artikala
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +379,Received From,je primljen od
-DocType: Payment Entry,Write Off Difference Amount,Otpis razlike u iznosu
-DocType: Task,Closing Date,Datum zatvaranja
-DocType: Payment Entry,Cheque/Reference Date,Datum izvoda
-DocType: Production Plan Item,Planned Qty,Planirana količina
-DocType: Repayment Schedule,Payment Date,Datum plaćanja
-DocType: Vehicle,Additional Details,Dodatni detalji
-DocType: Company,Create Chart Of Accounts Based On,Kreiraj kontni plan prema
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +244,You can not change rate if BOM mentioned agianst any item,Не можете променити цену ако постоји Саставница за било коју ставку.
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Otvori To Do
-DocType: Authorization Rule,Average Discount,Prosječan popust
-DocType: Item,Material Issue,Reklamacija robe
-DocType: Purchase Order Item,Billed Amt,Fakturisani iznos
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +261,Supplier Quotation {0} created,Ponuda dobavljaču {0} је kreirana
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},Nije dozvoljeno mijenjati Promjene na zalihama starije od {0}
-apps/erpnext/erpnext/public/js/event.js +27,Add Employees,Dodaj Zaposlenog
-apps/erpnext/erpnext/config/hr.py +394,Setting up Employees,Podešavanja Zaposlenih
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +96,Warehouse not found in the system,Skladište nije pronađeno u sistemu
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +264,Attendance for employee {0} is already marked for this day,Prisustvo zaposlenog {0} је već označeno za ovaj dan
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +349,Employee relieved on {0} must be set as 'Left',"Zaposleni smijenjen na {0} mora biti označen kao ""Napustio"""
-DocType: Sales Invoice, Shipping Bill Number,Broj isporuke
-,Lab Test Report,Izvještaj labaratorijskog testa
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +331,You cannot credit and debit same account at the same time,Не можете кредитирати и дебитовати исти налог у исто време.
-DocType: Sales Invoice,Customer Name,Naziv kupca
-DocType: Employee,Current Address,Trenutna adresa
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,Predstojeći događaji u kalendaru
-DocType: Accounts Settings,Make Payment via Journal Entry,Kreiraj uplatu kroz knjiženje
-DocType: Payment Request,Paid,Plaćeno
-DocType: Pricing Rule,Buying,Nabavka
-DocType: Stock Settings,Default Item Group,Podrazumijevana vrsta artikala
-apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +24,In Stock Qty,Na zalihama
-DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Umanjeni porezi i naknade (valuta preduzeća)
-DocType: Stock Entry,Additional Costs,Dodatni troškovi
-DocType: Project Task,Pending Review,Čeka provjeru
-DocType: Item Default,Default Selling Cost Center,Podrazumijevani centar troškova
-apps/erpnext/erpnext/public/js/pos/pos.html +109,No Customers yet!,Još uvijek nema kupaca!
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +909,Sales Return,Povraćaj prodaje
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +628,No Items added to cart,Nema dodatih artikala na računu
-apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,Ovo je zasnovano na transkcijama ovog klijenta. Pogledajte vremensku liniju ispod za dodatne informacije
-DocType: Project Task,Make Timesheet,Kreiraj potrošeno vrijeme
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +69,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Upozorenje: Prodajni nalog {0}već postoji veza sa porudžbenicom kupca {1}
-DocType: Healthcare Settings,Healthcare Settings,Podešavanje klinike
-apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +39,Accounting Ledger,Analitička kartica
-DocType: Stock Entry,Total Outgoing Value,Ukupna vrijednost isporuke
-apps/erpnext/erpnext/controllers/selling_controller.py +265,Sales Order {0} is {1},Prodajni nalog {0} је {1}
-DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Podesi automatski serijski broj da koristi FIFO
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Novi kupci
-apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Prije prodaje
-DocType: POS Customer Group,POS Customer Group,POS grupa kupaca
-DocType: Quotation,Shopping Cart,Korpa sa sajta
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Rezervisana za proizvodnju
-DocType: Pricing Rule,Pricing Rule Help,Pravilnik za cijene pomoć
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +35,Ageing Range 2,Opseg dospijeća 2
-DocType: Employee Benefit Application,Employee Benefits,Primanja Zaposlenih
-DocType: POS Item Group,POS Item Group,POS Vrsta artikala
-DocType: Lead,Lead,Lead
-DocType: HR Settings,Employee Settings,Podešavanja zaposlenih
-apps/erpnext/erpnext/templates/pages/home.html +32,View All Products,Pogledajte sve proizvode
-DocType: Patient Medical Record,Patient Medical Record,Medicinski karton pacijenta
-DocType: Student Attendance Tool,Batch,Serija
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +928,Purchase Receipt,Prijem robe
-DocType: Item,Warranty Period (in days),Garantni rok (u danima)
-apps/erpnext/erpnext/config/selling.py +28,Customer database.,Korisnička baza podataka
-DocType: Attendance,Attendance Date,Datum prisustva
-DocType: Supplier Scorecard,Notify Employee,Obavijestiti Zaposlenog
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +46,User ID not set for Employee {0},Korisnički ID nije podešen za Zaposlenog {0}
-,Stock Projected Qty,Projektovana količina na zalihama
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +408,Make Payment,Kreiraj plaćanje
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Ne možete obrisati fiskalnu godinu {0}. Fiskalna  {0} godina je označena kao trenutna u globalnim podešavanjima.
-apps/erpnext/erpnext/stock/stock_ledger.py +382,{0} units of {1} needed in {2} to complete this transaction.,Željenu količinu {0} za artikal {1} je potrebno dodati na {2} da bi dovršili transakciju..
-,Item-wise Sales Register,Prodaja po artiklima
-DocType: Item Tax,Tax Rate,Poreska stopa
-DocType: GL Entry,Remarks,Napomena
-DocType: Opening Invoice Creation Tool,Sales,Prodaja
-DocType: Pricing Rule,Pricing Rule,Pravilnik za cijene
-DocType: Products Settings,Products Settings,Podešavanje proizvoda
-DocType: Healthcare Practitioner,Mobile,Mobilni
-DocType: Purchase Invoice Item,Price List Rate,Cijena
-DocType: Purchase Invoice Item,Discount Amount,Vrijednost popusta
-,Sales Invoice Trends,Trendovi faktura prodaje
-apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py +110,You don't have enought Loyalty Points to redeem,Немате довољно Бодова Лојалности.
-DocType: Purchase Invoice,Tax Breakup,Porez po pozicijama
-DocType: Asset Maintenance Log,Task,Zadatak
-apps/erpnext/erpnext/stock/doctype/item/item.js +359,Add / Edit Prices,Dodaj / Izmijeni cijene
-,Item Prices,Cijene artikala
-DocType: Additional Salary,Salary Component,Компонента плате
-DocType: Sales Invoice,Customer's Purchase Order Date,Datum porudžbenice kupca
-DocType: Item,Country of Origin,Zemlja porijekla
-apps/erpnext/erpnext/hr/doctype/department_approver/department_approver.py +17,Please select Employee Record first.,Molimo izaberite registar Zaposlenih prvo
-DocType: Blanket Order,Order Type,Vrsta porudžbine
-DocType: BOM Item,Rate & Amount,Cijena i iznos sa rabatom
-DocType: Pricing Rule,For Price List,Za cjenovnik
-DocType: Purchase Invoice,Tax ID,Poreski broj
-DocType: Job Card,WIP Warehouse,Wip skladište
-,Itemwise Recommended Reorder Level,Pregled preporučenih nivoa dopune
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +408,{0} against Bill {1} dated {2},{0} veza sa računom {1} na datum {2}
-apps/erpnext/erpnext/accounts/doctype/account/account.py +113,You are not authorized to set Frozen value,Немате дозволу да постављате замрзнуту вредност
-,Requested Items To Be Ordered,Tražene stavke za isporuku
-DocType: Employee Attendance Tool,Unmarked Attendance,Neobilježeno prisustvo
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +657,Sales Order {0} is not submitted,Prodajni nalog {0} nije potvrđen
-DocType: Item,Default Material Request Type,Podrazumijevani zahtjev za tip materijala
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +42,Sales Pipeline,Prodajna linija
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +617,Already completed,Već završen
-DocType: Production Plan Item,Ordered Qty,Poručena kol
-DocType: Item,Sales Details,Detalji prodaje
-apps/erpnext/erpnext/config/learn.py +11,Navigating,Navigacija
-apps/erpnext/erpnext/utilities/user_progress.py +138,Your Products or Services,Vaši artikli ili usluge
-DocType: Contract,CRM,CRM
-apps/erpnext/erpnext/public/js/setup_wizard.js +51,The Brand,Brend
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +165,Quotation {0} is cancelled,Ponuda {0} je otkazana
-DocType: Pricing Rule,Item Code,Šifra artikla
-DocType: Purchase Order,Customer Mobile No,Broj telefona kupca
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +92,Reorder Qty,Kol. za dopunu
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118,Move Item,Premještanje artikala
-DocType: Buying Settings,Buying Settings,Podešavanja nabavke
-DocType: Asset Movement,From Employee,Od Zaposlenog
-DocType: Driver,Fleet Manager,Menadžer transporta
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +51,Stock Levels,Nivoi zalihe
-DocType: Sales Invoice Item,Rate With Margin (Company Currency),Cijena sa popustom (Valuta preduzeća)
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +278,Closing (Cr),Saldo (Po)
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +622,Product Bundle,Sastavnica
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +21,Sales and Returns,Prodaja i povraćaji
-apps/erpnext/erpnext/accounts/page/pos/pos.js +801,Sync Master Data,Sinhronizuj podatke iz centrale
-DocType: Sales Person,Sales Person Name,Ime prodajnog agenta
-DocType: Landed Cost Voucher,Purchase Receipts,Prijemi robe
-apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Prilagođavanje formi
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +19,Attendance for employee {0} is already marked,Prisustvo zaposlenog {0} je već označeno
-DocType: Project,% Complete Method,% metod vrednovanja završetka projekta
-DocType: Purchase Invoice,Overdue,Istekao
-DocType: Purchase Invoice,Posting Time,Vrijeme izrade računa
-DocType: Stock Entry,Purchase Receipt No,Broj prijema robe
-DocType: Project,Expected End Date,Očekivani datum završetka
-apps/erpnext/erpnext/projects/doctype/project/project.py +84,Expected End Date can not be less than Expected Start Date,Očekivani datum završetka ne može biti manji od očekivanog dana početka
-DocType: Customer,Customer Primary Contact,Primarni kontakt kupca
-DocType: Project,Expected Start Date,Očekivani datum početka
-DocType: Supplier,Credit Limit,Kreditni limit
-DocType: Item,Item Tax,Porez
-DocType: Pricing Rule,Selling,Prodaja
-DocType: Purchase Order,Customer Contact,Kontakt kupca
-apps/erpnext/erpnext/stock/doctype/item/item.py +578,Item {0} does not exist,Artikal {0} ne postoji
-apps/erpnext/erpnext/utilities/user_progress.py +247,Add Users,Dodaj korisnike
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +81,Select Serial Numbers,Izaberite serijske brojeve
-DocType: Bank Reconciliation Detail,Payment Entry,Uplate
-DocType: Purchase Invoice,In Words,Riječima
-DocType: HR Settings,Employee record is created using selected field. ,Izvještaj o Zaposlenom se kreira korišćenjem izabranog polja.
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},Serijski broj {0} ne pripada otpremnici {1}
-DocType: Issue,Support,Podrška
-DocType: Production Plan,Get Sales Orders,Pregledaj prodajne naloge
-DocType: Stock Ledger Entry,Stock Ledger Entry,Unos zalihe robe
-apps/erpnext/erpnext/config/projects.py +36,Gantt chart of all tasks.,Gantov grafikon svih zadataka
-DocType: Purchase Invoice Item,Price List Rate (Company Currency),Cijena (Valuta preduzeća)
-DocType: Delivery Stop,Address Name,Naziv adrese
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +54,Another Sales Person {0} exists with the same Employee id,Postoji još jedan Prodavac {0} sa istim ID zaposlenog
-DocType: Item Group,Item Group Name,Naziv vrste artikala
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +175,A Customer Group exists with same name please change the Customer name or rename the Customer Group,Isto ime grupe kupca već postoji. Promijenite ime kupca ili izmijenite grupu kupca
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +586,Warning: Another {0} # {1} exists against stock entry {2},Upozorenje: Još jedan  {0} # {1} postoji u vezanom Unosu zaliha {2}
-apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,Dobavljač
-DocType: Item,Has Serial No,Ima serijski broj
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +31,Employee {0} on Half day on {1},Zaposleni {0} na pola radnog vremena {1}
-DocType: Payment Entry,Difference Amount (Company Currency),Razlika u iznosu (Valuta)
-apps/erpnext/erpnext/public/js/utils.js +56,Add Serial No,Dodaj serijski broj
-apps/erpnext/erpnext/config/accounts.py +35,Company and Accounts,Preduzeće i računi
-DocType: Employee,Current Address Is,Trenutna adresa je
-DocType: Payment Entry,Unallocated Amount,Nepovezani iznos
-apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +58,Show zero values,Prikaži vrijednosti sa nulom
-DocType: Bank Account,Address and Contact,Adresa i kontakt
-,Supplier-Wise Sales Analytics,Analiza Dobavljačeve pametne prodaje
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +348,Payment Entry is already created,Uplata je već kreirana
-DocType: Purchase Invoice Item,Item,Artikal
-DocType: Purchase Invoice,Unpaid,Neplaćen
-DocType: Purchase Invoice Item,Net Rate,Neto cijena sa rabatom
-DocType: Project User,Project User,Projektni user
-DocType: Item,Customer Items,Proizvodi kupca
-apps/erpnext/erpnext/stock/doctype/item/item.py +840,Item {0} is cancelled,Stavka {0} je otkazana
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +89,Balance Value,Stanje vrijed.
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +98,Sales Order required for Item {0},Prodajni nalog je obavezan za artikal {0}
-DocType: Clinical Procedure,Patient,Pacijent
-DocType: Stock Entry,Default Target Warehouse,Prijemno skladište
-DocType: GL Entry,Voucher No,Br. dokumenta
-apps/erpnext/erpnext/education/api.py +80,Attendance has been marked successfully.,Prisustvo je uspješno obilježeno.
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +398,Serial No {0} created,Serijski broj {0} kreiran
-DocType: Account,Asset,Osnovna sredstva
-DocType: Payment Entry,Received Amount,Iznos uplate
-apps/erpnext/erpnext/hr/doctype/department/department.js +14,You cannot edit root node.,Не можете уређивати коренски чвор.
-,Sales Funnel,Prodajni lijevak
-DocType: Sales Invoice,Payment Due Date,Datum dospijeća fakture
-apps/erpnext/erpnext/config/healthcare.py +8,Consultation,Pregled
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8,Related,Povezan
-DocType: Warehouse,Warehouse Name,Naziv skladišta
-DocType: Authorization Rule,Customer / Item Name,Kupac / Naziv proizvoda
-DocType: Timesheet,Total Billed Amount,Ukupno fakturisano
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +85,In Value,Prijem vrije.
-DocType: Expense Claim,Employees Email Id,ID email Zaposlenih
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +54,Tree Type,Tip stabla
-DocType: Stock Entry,Update Rate and Availability,Izmijenite cijenu i dostupnost
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1156,Supplier Quotation,Ponuda dobavljača
-DocType: Material Request Item,Quantity and Warehouse,Količina i skladište
-DocType: Purchase Invoice,Taxes and Charges Added,Porezi i naknade dodate
-DocType: Work Order,Warehouses,Skladišta
-DocType: SMS Center,All Customer Contact,Svi kontakti kupca
-apps/erpnext/erpnext/accounts/doctype/account/account.js +78,Ledger,Skladišni karton
-DocType: Quotation,Quotation Lost Reason,Razlog gubitka ponude
-DocType: Purchase Invoice,Return Against Purchase Invoice,Povraćaj u vezi sa Fakturom nabavke
-DocType: Sales Invoice Item,Brand Name,Naziv brenda
-DocType: Account,Stock,Zalihe
-DocType: Customer Group,Customer Group Name,Naziv grupe kupca
-DocType: Item,Is Sales Item,Da li je prodajni artikal
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +119,Invoiced Amount,Fakturisano
-DocType: Purchase Invoice,Edit Posting Date and Time,Izmijeni datum i vrijeme dokumenta
-,Inactive Customers,Neaktivni kupci
-DocType: Stock Entry Detail,Stock Entry Detail,Detalji unosa zaliha
-DocType: Sales Invoice,Accounting Details,Računovodstveni detalji
-DocType: Asset Movement,Stock Manager,Menadžer zaliha
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +22,As on Date,Na datum
-DocType: Serial No,Is Cancelled,Je otkazan
-DocType: Naming Series,Setup Series,Podešavanje tipa dokumenta
-,Point of Sale,Kasa
-DocType: C-Form Invoice Detail,Invoice No,Broj fakture
-DocType: Landed Cost Item,Purchase Receipt Item,Stavka Prijema robe
-DocType: Bank Statement Transaction Payment Item,Invoices,Fakture
-DocType: Project,Task Progress,% završenosti zadataka
-DocType: Employee Attendance Tool,Employee Attendance Tool,Alat za prisustvo Zaposlenih
-DocType: Salary Slip,Payment Days,Dana za plaćanje
-apps/erpnext/erpnext/config/hr.py +231,Recruitment,Zapošljavanje
-DocType: Purchase Invoice,Taxes and Charges Calculation,Izračun Poreza
-DocType: Appraisal,For Employee,Za Zaposlenog
-apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Uslovi i odredbe šablon
-DocType: Vehicle Service,Change,Kusur
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +105,Stock Entry {0} created,Unos zaliha {0} je kreiran
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1181,Search Item (Ctrl + i),Pretraga artikala (Ctrl + i)
-apps/erpnext/erpnext/templates/generators/item.html +101,View in Cart,Pogledajte u korpi
-apps/erpnext/erpnext/stock/get_item_details.py +405,Item Price updated for {0} in Price List {1},Cijena artikla je izmijenjena {0} u cjenovniku {1}
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +623,Discount,Popust
-DocType: Packing Slip,Net Weight UOM,Neto težina  JM
-DocType: Bank Account,Party Type,Tip partije
-DocType: Selling Settings,Sales Order Required,Prodajni nalog je obavezan
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1108,Search Item,Pretraži artikal
-,Delivered Items To Be Billed,Nefakturisana isporučena roba
-DocType: Account,Debit,Duguje
-DocType: Patient Appointment,Date TIme,Datum i vrijeme
-DocType: Bank Reconciliation Detail,Payment Document,Dokument za plaćanje
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +184,You can not enter current voucher in 'Against Journal Entry' column,"Неможете унети тренутни ваучер у колону ""На основу ставке у журналу"""
-DocType: Purchase Invoice,In Words (Company Currency),Riječima (valuta kompanije)
-,Purchase Receipt Trends,Trendovi prijema robe
-DocType: Employee Leave Approver,Employee Leave Approver,Odobreno odsustvo Zaposlenog
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Fiskalna godina {0} ne postoji
-DocType: Purchase Invoice Item,Accepted Warehouse,Prihvaćeno skladište
-DocType: Account,Income Account,Račun prihoda
-DocType: Journal Entry Account,Account Balance,Knjigovodstveno stanje
-apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Expected Start Date' can not be greater than 'Expected End Date',Očekivani datum početka ne može biti veći od očekivanog datuma završetka
-DocType: Training Event,Employee Emails,Elektronska pošta Zaposlenog
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Opening Qty,Početna količina
-DocType: Item,Reorder level based on Warehouse,Nivo dopune u zavisnosti od skladišta
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +84,To Warehouse,U skladište
-DocType: Account,Is Group,Je grupa
-DocType: Purchase Invoice,Contact Person,Kontakt osoba
-DocType: Item,Item Code for Suppliers,Dobavljačeva šifra
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +893,Return / Debit Note,Povraćaj / knjižno zaduženje
-DocType: Request for Quotation Supplier,Request for Quotation Supplier,Zahtjev za ponudu dobavljača
-,LeaderBoard,Tabla
-DocType: Lab Test Groups,Lab Test Groups,Labaratorijske grupe
-DocType: Training Result Employee,Training Result Employee,Rezultati obuke Zaposlenih
-DocType: Serial No,Invoice Details,Detalji fakture
-apps/erpnext/erpnext/config/accounts.py +130,Banking and Payments,Bakarstvo i plaćanja
-DocType: Additional Salary,Employee Name,Ime Zaposlenog
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Active Leads / Customers,Активни Леадс / Kupci
-DocType: POS Profile,Accounting,Računovodstvo
-DocType: Payment Entry,Party Name,Ime partije
-DocType: Item,Manufacture,Proizvodnja
-apps/erpnext/erpnext/templates/pages/projects.html +27,New task,Novi zadatak
-DocType: Journal Entry,Accounts Payable,Obaveze prema dobavljačima
-DocType: Purchase Invoice,Shipping Address,Adresa isporuke
-DocType: Bank Statement Transaction Invoice Item,Outstanding Amount,Preostalo za uplatu
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Naziv novog skladišta
-apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,Fakturisani iznos
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Stanje zalihe
-,Item Shortage Report,Izvještaj o negativnim zalihama
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +383,Transaction reference no {0} dated {1},Broj izvoda {0} na datum {1}
-apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Kreiraj prodajni nalog
-DocType: Purchase Invoice,Items,Artikli
-,Employees working on a holiday,Zaposleni koji rade za vrijeme praznika
-DocType: Payment Entry,Allocate Payment Amount,Poveži uplaćeni iznos
-DocType: Patient,Patient ID,ID pacijenta
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +263,Printed On,Datum i vrijeme štampe
-DocType: Sales Invoice,Debit To,Zaduženje za
-apps/erpnext/erpnext/config/setup.py +14,Global Settings,Globalna podešavanja
-apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +18,Make Employee,Keriraj Zaposlenog
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +244,Atleast one warehouse is mandatory,Minimum jedno skladište je obavezno
-DocType: Price List,Price List Name,Naziv cjenovnika
-DocType: Asset,Journal Entry for Scrap,Knjiženje rastura i loma
-DocType: Item,Website Warehouse,Skladište web sajta
-DocType: Sales Invoice Item,Customer's Item Code,Šifra kupca
-DocType: Bank Guarantee,Supplier,Dobavljači
-DocType: Purchase Invoice,Additional Discount Amount,Iznos dodatnog popusta
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Datum početka projekta
-DocType: Announcement,Student,Student
-apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18,Suplier Name,Naziv dobavljača
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,Prijem količine
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +68,Selling Rate,Prodajna cijena
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64,Import Successful!,Uvoz uspješan!
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +539,Stock cannot be updated against Delivery Note {0},Zaliha se ne može promijeniti jer je vezana sa otpremnicom {0}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +742,You are in offline mode. You will not be able to reload until you have network.,Радите без интернета. Нећете моћи да учитате страницу док се не повежете.
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +542,Form View,Prikaži kao formu
-apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +81,Shortage Qty,Manjak kol.
-DocType: Drug Prescription,Hour,Sat
-apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +55,Item Group Tree,Stablo vrste artikala
-DocType: POS Profile,Update Stock,Ažuriraj zalihu
-DocType: Crop,Target Warehouse,Ciljno skladište
-,Delivery Note Trends,Trendovi Otpremnica
-DocType: Stock Entry,Default Source Warehouse,Izdajno skladište
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +535,"{0}: Employee email not found, hence email not sent","{0}: Email zaposlenog nije pronađena, stoga email nije poslat"
-apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,Sva skladišta
-DocType: Asset Value Adjustment,Difference Amount,Razlika u iznosu
-DocType: Journal Entry,User Remark,Korisnička napomena
-DocType: Notification Control,Quotation Message,Ponuda - poruka
-DocType: Purchase Order,% Received,% Primljeno
-DocType: Journal Entry,Stock Entry,Unos zaliha
-apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +40,Sales Price List,Prodajni cjenovnik
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +67,Avg. Selling Rate,Prosječna prodajna cijena
-DocType: Item,End of Life,Kraj proizvodnje
-DocType: Payment Entry,Payment Type,Vrsta plaćanja
-DocType: Selling Settings,Default Customer Group,Podrazumijevana grupa kupaca
-DocType: Bank Account,Party,Partija
-,Total Stock Summary,Ukupan pregled zalihe
-DocType: Purchase Invoice,Net Total (Company Currency),Ukupno bez PDV-a (Valuta preduzeća)
-DocType: Healthcare Settings,Patient Name,Ime pacijenta
-apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,Otpisati
-DocType: Notification Control,Delivery Note Message,Poruka na otpremnici
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"Cannot delete Serial No {0}, as it is used in stock transactions","Ne može se obrisati serijski broj {0}, dok god se nalazi u dijelu Promjene na zalihama"
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +660,Delivery Note {0} is not submitted,Otpremnica {0} nije potvrđena
-apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29,New Employee,Novi Zaposleni
-apps/erpnext/erpnext/public/js/pos/pos.html +98,Customers in Queue,Kupci na čekanju
-DocType: Purchase Invoice,Price List Currency,Valuta Cjenovnika
-DocType: Authorization Rule,Applicable To (Employee),Primjenljivo na (zaposlene)
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +96,Project Manager,Projektni menadzer
-DocType: Journal Entry,Accounts Receivable,Potraživanja od kupaca
-DocType: Purchase Invoice Item,Rate,Cijena sa popustom
-DocType: Project Task,View Task,Pogledaj zadatak
-DocType: Employee Education,Employee Education,Obrazovanje Zaposlenih
-DocType: Account,Expense,Rashod
-apps/erpnext/erpnext/config/learn.py +107,Newsletters,Newsletter-i
-DocType: Purchase Invoice,Select Supplier Address,Izaberite adresu dobavljača
-apps/erpnext/erpnext/stock/get_item_details.py +521,Price List {0} is disabled or does not exist,Cjenovnik {0} je zaključan ili ne postoji
-DocType: Delivery Note,Billing Address Name,Naziv adrese za naplatu
-DocType: Restaurant Order Entry,Add Item,Dodaj stavku
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +108,All Customer Groups,Sve grupe kupca
-,Employee Birthday,Rođendan Zaposlenih
-DocType: Project,Total Billed Amount (via Sales Invoices),Ukupno fakturisano (putem fakture prodaje)
-DocType: Purchase Invoice Item,Weight UOM,JM Težina
-DocType: Purchase Invoice Item,Stock Qty,Zaliha
-DocType: Delivery Note,Return Against Delivery Note,Povraćaj u vezi sa otpremnicom
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +28,Ageing Range 1,Opseg dospijeća 1
-DocType: Serial No,Incoming Rate,Nabavna cijena
-DocType: Projects Settings,Timesheets,Potrošnja vremena
-DocType: Upload Attendance,Attendance From Date,Datum početka prisustva
-apps/erpnext/erpnext/public/js/pos/pos.html +115,Stock Items,Artikli na zalihama
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2227,New Cart,Nova korpa
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +83,Opening Value,Početna vrijednost
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60,"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Podešavanje stanja na {0}, pošto Zaposleni koji se priključio Prodavcima nema koririsnički ID {1}"
-DocType: Upload Attendance,Import Attendance,Uvoz prisustva
-apps/erpnext/erpnext/config/selling.py +184,Analytics,Analitika
-DocType: Email Digest,Bank Balance,Stanje na računu
-DocType: Education Settings,Employee Number,Broj Zaposlenog
-DocType: Purchase Receipt Item,Rate and Amount,Cijena i vrijednost sa popustom
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +237,'Total','Ukupno bez PDV-a'
-DocType: Purchase Invoice,Total Taxes and Charges,Porez
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +266,No active or default Salary Structure found for employee {0} for the given dates,Nisu pronađene aktivne ili podrazumjevane strukture plate za Zaposlenog {0} za dati period
-DocType: Purchase Order Item,Supplier Part Number,Dobavljačeva šifra
-DocType: Project Task,Project Task,Projektni zadatak
-DocType: Item Group,Parent Item Group,Nadređena Vrsta artikala
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +113,Mark Attendance,Označi prisustvo
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229,{0} created,Kreirao je korisnik {0}
-DocType: Purchase Order,Advance Paid,Avansno plačanje
-apps/erpnext/erpnext/stock/doctype/item/item.js +41,Projected,Projektovana količina na zalihama
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Nivo dopune
-DocType: Opportunity,Customer / Lead Address,Kupac / Adresa lead-a
-DocType: Buying Settings,Default Buying Price List,Podrazumijevani Cjenovnik
-DocType: Purchase Invoice Item,Qty,Kol
-DocType: Mode of Payment,General,Opšte
-DocType: Supplier,Default Payable Accounts,Podrazumijevani nalog za plaćanje
-apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Cijena: {0}
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1659,Write Off Amount,Zaokruženi iznos
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +139,Total Outstanding Amount,Preostalo za plaćanje
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +359,Not Paid and Not Delivered,Nije plaćeno i nije isporučeno
-DocType: Asset Maintenance Log,Planned,Planirano
-DocType: Bank Reconciliation,Total Amount,Ukupan iznos
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +177,Please select Price List,Izaberite cjenovnik
-DocType: Quality Inspection,Item Serial No,Seriski broj artikla
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +388,Customer Service,Usluga kupca
-DocType: Project Task,Working,U toku
-DocType: Cost Center,Stock User,Korisnik zaliha
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +27,General Ledger,Glavna knjiga
-DocType: C-Form,Received Date,Datum prijema
-apps/erpnext/erpnext/config/projects.py +13,Project master.,Projektni master
-DocType: Item Price,Valid From,Važi od
-,Purchase Order Trends,Trendovi kupovina
-DocType: Quotation,In Words will be visible once you save the Quotation.,Sačuvajte Predračun da bi Ispis slovima bio vidljiv
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Projektovana količina
-apps/erpnext/erpnext/config/selling.py +234,Customer Addresses And Contacts,Kontakt i adresa kupca
-DocType: Healthcare Settings,Employee name and designation in print,Ime i pozicija Zaposlenog
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1161,For Warehouse,Za skladište
-apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +41,Purchase Price List,Nabavni cjenovnik
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +83,Accounts Payable Summary,Pregled obaveze prema dobavljačima
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +224,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Otpremnice {0} moraju biti otkazane prije otkazivanja prodajnog naloga
-DocType: Loan,Total Payment,Ukupno plaćeno
-DocType: POS Settings,POS Settings,POS podešavanja
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Buying Amount,Iznos nabavke
-DocType: Purchase Invoice Item,Valuation Rate,Prosječna nab. cijena
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,ID Projekta
-DocType: Purchase Invoice,Invoice Copy,Kopija Fakture
-apps/erpnext/erpnext/projects/doctype/project/project.py +279,You have been invited to collaborate on the project: {0},Позвани сте да сарађујете на пројекту: {0}
-DocType: Journal Entry Account,Purchase Order,Porudžbenica
-DocType: Sales Invoice Item,Rate With Margin,Cijena sa popustom
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1182,"Search by item code, serial number, batch no or barcode","Pretraga po šifri, serijskom br. ili bar kodu"
-DocType: GL Entry,Voucher Type,Vrsta dokumenta
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222,Serial No {0} has already been received,Serijski broj {0} je već primljen
-apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Uvoz i izvoz podataka
-apps/erpnext/erpnext/controllers/accounts_controller.py +617,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Ukupan avns({0}) na porudžbini {1} ne može biti veći od Ukupnog iznosa ({2})
-DocType: Material Request,% Ordered,%  Poručenog
-apps/erpnext/erpnext/stock/get_item_details.py +523,Price List not selected,Cjenovnik nije odabran
-DocType: POS Profile,Apply Discount On,Primijeni popust na
-DocType: Item,Total Projected Qty,Ukupna projektovana količina
-DocType: Shipping Rule Condition,Shipping Rule Condition,Uslovi  pravila nabavke
-apps/erpnext/erpnext/config/stock.py +317,Opening Stock Balance,Početno stanje zalihe
-,Customer Credit Balance,Kreditni limit kupca
-apps/erpnext/erpnext/public/js/templates/address_list.html +20,No address added yet.,Adresa još nije dodata.
-DocType: Subscription,Net Total,Ukupno bez PDV-a
-DocType: Sales Invoice,Total Qty,Ukupna kol.
-DocType: Purchase Invoice,Return,Povraćaj
-DocType: Sales Order Item,Delivery Warehouse,Skladište dostave
-DocType: Purchase Invoice,Total (Company Currency),Ukupno bez PDV-a (Valuta)
-DocType: Sales Invoice,Change Amount,Kusur
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1083,Opportunity,Prilika
-DocType: Sales Order,Fully Delivered,Kompletno isporučeno
-DocType: Leave Control Panel,Leave blank if considered for all employee types,Ostavite prazno ako se podrazumijeva za sve tipove Zaposlenih
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +594,Disc,Popust
-DocType: Customer,Default Price List,Podrazumijevani cjenovnik
-DocType: Bank Statement Transaction Invoice Item,Journal Entry,Knjiženje
-DocType: Purchase Invoice,Apply Additional Discount On,Primijeni dodatni popust na
-apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,Ovo je zasnovano na transkcijama ovog dobavljača. Pogledajte vremensku liniju ispod za dodatne informacije
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,Iznad 90 dana
-apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +49,You have already assessed for the assessment criteria {}.,Већ сте оценили за критеријум оцењивања {}.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +994,Serial Numbers in row {0} does not match with Delivery Note,Serijski broj na poziciji {0} se ne poklapa sa otpremnicom
-apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Novi kontakt
-DocType: Cashier Closing,Returns,Povraćaj
-DocType: Delivery Note,Delivery To,Isporuka za
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Vrijednost Projekta
-DocType: Warehouse,Parent Warehouse,Nadređeno skladište
-DocType: Payment Request,Make Sales Invoice,Kreiraj fakturu prodaje
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +594,Del,Obriši
-apps/erpnext/erpnext/public/js/stock_analytics.js +58,Select Warehouse...,Izaberite skladište...
-DocType: Payment Reconciliation,Invoice/Journal Entry Details,Faktura / Detalji knjiženja
-,Projected Quantity as Source,Projektovana izvorna količina
-DocType: Asset Maintenance,Manufacturing User,Korisnik u proizvodnji
-apps/erpnext/erpnext/utilities/activation.py +99,Create Users,Kreiraj korisnike
-apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15,Price,Cijena
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Izdavanje Kol.
-DocType: Supplier Scorecard Scoring Standing,Employee,Zaposleni
-apps/erpnext/erpnext/config/projects.py +24,Project activity / task.,Projektna aktivnost / zadatak
-DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Rezervisano skladište u Prodajnom nalogu / Skladište gotovog proizvoda
-DocType: Appointment Type,Physician,Ljekar
-DocType: Opening Invoice Creation Tool Item,Quantity,Količina
-DocType: Buying Settings,Purchase Receipt Required,Prijem robe je obavezan
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +38,Currency is required for Price List {0},Valuta je obavezna za Cjenovnik {0}
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +87,Out Value,Izdavanje vrije.
-DocType: Loyalty Program,Customer Group,Grupa kupaca
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +161,You are not authorized to add or update entries before {0},Немате дозволу да додајете или ажурирате ставке пре {0}
-DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Skladište se jedino može promijeniti u dijelu Unos zaliha / Otpremnica / Prijem robe
-apps/erpnext/erpnext/hooks.py +148,Request for Quotations,Zahtjev za ponude
-apps/erpnext/erpnext/config/desktop.py +159,Learn,Naučite
-DocType: Timesheet,Employee Detail,Detalji o Zaposlenom
-DocType: POS Profile,Ignore Pricing Rule,Zanemari pravilnik o cijenama
-DocType: Purchase Invoice,Additional Discount,Dodatni popust
-DocType: Payment Entry,Cheque/Reference No,Broj izvoda
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +46,Attendance date can not be less than employee's joining date,Datum prisustva ne može biti raniji od datuma ulaska zaposlenog
-apps/erpnext/erpnext/utilities/user_progress.py +146,Box,Kutija
-DocType: Payment Entry,Total Allocated Amount,Ukupno povezani iznos
-apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Sve adrese
-apps/erpnext/erpnext/utilities/user_progress.py +39,Opening Balances,Početna stanja
-apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Korisnici i dozvole
-apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py +68,"You can only plan for upto {0} vacancies and budget {1} \
+Yield UOM,Јединица мере приноса
+Default Supplier,Podrazumijevani dobavljač
+Select Patient,Izaberite pacijenta,
+Opening,Početno stanje,
+Customer Groups,Grupe kupaca,
+Item Manager,Menadžer artikala,
+Fiscal Year Company,Fiskalna godina preduzeća,
+Patient Appointment,Zakazivanje pacijenata,
+Show In Website,Prikaži na web sajtu,
+Paid Amount,Uplaćeno,
+Total Paid Amount,Ukupno plaćeno,
+Purchase Receipt {0} is not submitted,Prijem robe {0} nije potvrđen,
+Items and Pricing,Proizvodi i cijene,
+Account Paid From,Račun plaćen preko,
+Create customer quotes,Kreirajte bilješke kupca,
+Supplier Warehouse,Skladište dobavljača,
+Customer is required,Kupac je obavezan podatak,
+Manufacturer,Proizvođač
+Selling Amount,Prodajni iznos,
+Please set the Date Of Joining for employee {0},Molimo podesite datum zasnivanja radnog odnosa {0}
+Allow over delivery or receipt upto this percent,Dozvolite isporukuili prijem robe ukoliko ne premaši ovaj procenat,
+Orders,Porudžbine,
+Stock Transactions,Promjene na zalihama,
+You are not authorized to approve leaves on Block Dates,Немате дозволу да одобравате одсуства на Блок Датумима.
+Daily Timesheet Summary,Pregled dnevnog potrošenog vremena,
+View Timesheet,Pogledaj potrošeno vrijeme,
+Rounded Total (Company Currency),Zaokruženi ukupan iznos (valuta preduzeća)
+Salary Slip of employee {0} already created for this period,Isplatna lista Zaposlenog {0} kreirana je već za ovaj period,
+"If this item has variants, then it cannot be selected in sales orders etc.","Ako ovaj artikal ima varijante, onda ne može biti biran u prodajnom nalogu."
+You can only redeem max {0} points in this order.,Можете унети највише {0} поена у овој наруџбини.
+No leave record found for employee {0} for {1},Nije nađena evidancija o odsustvu Zaposlenog {0} za {1}
+Discount on Price List Rate (%),Popust na cijene iz cjenovnika (%)
+Groups,Grupe,
+Item Attribute,Atribut artikla,
+Amount in customer's currency,Iznos u valuti kupca,
+Warehouse is mandatory,Skladište je obavezan podatak,
+Stock Ageing,Starost zaliha,
+New Sales Orders,Novi prodajni nalozi,
+Invoice Created,Kreirana faktura,
+Employee Internal Work History,Interna radna istorija Zaposlenog,
+Cart is Empty,Korpa je prazna,
+Patient Details,Detalji o pacijentu,
+Stock Entry {0} is not submitted,Unos zaliha {0} nije potvrđen,
+Rest Of The World,Ostatak svijeta,
+Additional Operating Cost,Dodatni operativni troškovi,
+Rejected Warehouse,Odbijeno skladište,
+Manufacturing Manager,Menadžer proizvodnje,
+You are not present all day(s) between compensatory leave request days,Нисте присутни свих дана између захтева за компензацијски одмор.
+Is Fixed Asset,Artikal je osnovno sredstvo,
+POS,POS,
+Timesheet {0} is already completed or cancelled,Potrošeno vrijeme {0} je već potvrđeno ili otkazano,
+ (Half Day),(Pola dana)
+Net Weight,Neto težina,
+Attendance Record {0} exists against Student {1},Zapis o prisustvu {0} постоји kod studenata {1}
+Outstanding,Preostalo,
+Discount (%) on Price List Rate with Margin,Popust (%)
+Select Shipping Address,Odaberite adresu isporuke,
+Amount to Bill,Iznos za fakturisanje,
+Make Sales Orders to help you plan your work and deliver on-time,Kreiranje prodajnog naloga će vam pomoći da isplanirate svoje vrijeme i dostavite robu na vrijeme,
+Sync Offline Invoices,Sinhronizuj offline fakture,
+Manufacturing,Proizvodnja,
+{0}% Delivered,{0}% Isporučeno,
+Attendance,Prisustvo,
+Customer's Purchase Order No,Broj porudžbenice kupca,
+Please enter Sales Orders in the above table,U tabelu iznad unesite prodajni nalog,
+Report Date,Datum izvještaja,
+Item Groups,Vrste artikala,
+Discount Percentage,Procenat popusta,
+Gross Profit %,Bruto dobit%
+"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Овде можете дефинисати све задатке које је потребно извршити за ову жетву. Поље Дан говори дан на који је задатак потребно извршити, 1 је 1. дан, итд."
+Payment Request,Upit za plaćanje,
+Purchase Analytics,Analiza nabavke,
+Tree Details,Detalji stabla,
+Upload Attendance,Priloži evidenciju,
+Against,Povezano sa,
+Requested Amount,Traženi iznos,
+"Record of all communications of type email, phone, chat, visit, etc.","Snimanje svih komunikacija tipa email, telefon, poruke, posjete, itd."
+Customer Contact Email,Kontakt e-mail kupca,
+Primary Address Details,Detalji o primarnoj adresi,
+Above,Iznad,
+Variant Based On,Varijanta zasnovana na,
+Task Weight,Težina zadataka,
+Transaction ID,Transakcije,
+Allocated,Dodijeljeno,
+Add more items or open full form,Dodaj još stavki ili otvori kompletan prozor,
+Reserved for sale,Rezervisana za prodaju,
+Item Group,Vrste artikala,
+Age (Days),Starost (Dani)
+Opening (Dr),Početno stanje (Du)
+Total Outstanding Amt,Preostalo za plaćanje,
+Go to the Desktop and start using ERPNext,Idite na radnu površinu i krenite sa radom u programu,
+You can only have Plans with the same billing cycle in a Subscription,Сви Планови у Претплати морају имати исти циклус наплате
+Name and Employee ID,Ime i ID Zaposlenog,
+Invoice,Faktura,
+Invoice Date,Datum fakture,
+From Lead,Od Lead-a,
+Database of potential customers.,Baza potencijalnih kupaca,
+Project Status,Status Projekta,
+All Item Groups,Sve vrste artikala,
+Serial No {0} does not exist,Serijski broj {0} ne postoji,
+No contacts added yet.,Još uvijek nema dodatih kontakata,
+Ageing Range 3,Opseg dospijeća 3,
+Request for Quotation,Zahtjev za ponudu,
+Account Paid To,Račun plaćen u,
+Attendance can not be marked for future dates,Učesnik ne može biti označen za buduće datume,
+Sales Invoice No,Broj fakture prodaje,
+Timesheet,Potrošeno vrijeme,
+Don't send Employee Birthday Reminders,Nemojte slati podsjetnik o rođendanima Zaposlenih,
+Available Qty at Warehouse,Dostupna količina na skladištu,
+Foreign Trade Details,Spoljnotrgovinski detalji,
+Minimum Order Qty,Minimalna količina za poručivanje,
+No employees for the mentioned criteria,Za traženi kriterijum nema Zaposlenih,
+Fiscal Year,Fiskalna godina,
+Repack,Prepakovati,
+Please select a warehouse,Izaberite skladište,
+Received and Accepted,Primio i prihvatio,
+Project will be accessible on the website to these users,Projekat će biti dostupan na sajtu sledećim korisnicima,
+Upload HTML,Priloži HTML,
+Services,Usluge,
+Item Cart,Korpa sa artiklima,
+Total Paid Amt,Ukupno plaćeno,
+Warehouse Detail,Detalji o skldištu,
+Quotation Item,Stavka sa ponude,
+Employee Advance,Napredak Zaposlenog,
+Warehouse and Reference,Skladište i veza,
+{0} {1}: Account {2} is inactive,{0} {1}: Nalog {2} je neaktivan,
+Fiscal Year {0} not found,Fiskalna godina {0} nije pronađena,
+No Remarks,Nema napomene,
+Purchase Receipt Message,Poruka u Prijemu robe,
+Taxes and Charges Deducted,Umanjeni porezi i naknade,
+Include Payment (POS),Uključi POS plaćanje,
+Customer PO Details,Pregled porudžbine kupca,
+Total Invoiced Amt,Ukupno fakturisano,
+Select Brand...,Izaberite brend,
+Default Unit of Measure,Podrazumijevana jedinica mjere,
+Serial No,Serijski broj,
+Supplier Type,Tip dobavljača,
+Actual Qty {0} / Waiting Qty {1},Trenutna kol. {0} / Na čekanju {1}
+Individual,Fizičko lice,
+Partially Ordered,Djelimično poručeno,
+Posting Date,Datum dokumenta,
+Date Settings,Podešavanje datuma,
+Total Allocated Amount (Company Currency),Ukupan povezani iznos (Valuta)
+Income,Prihod,
+Add Items,Dodaj stavke,
+Price List not found or disabled,Cjenovnik nije pronađen ili je zaključan,
+Weight (In Kilogram),Težina (u kg)
+New Sales Invoice,Nova faktura,
+New Company,Novo preduzeće,
+Support Team,Tim za podršku,
+Valuation Method,Način vrednovanja,
+Project Type,Tip Projekta,
+Returned Qty,Vraćena kol.
+Additional Discount Amount (Company Currency),Iznos dodatnog popusta (valuta preduzeća)
+Employee Information,Informacije o Zaposlenom,
+'Days Since Last Order' must be greater than or equal to zero,"""Dana od poslednje porudžbine"" mora biti veće ili jednako nuli"
+Maintenance,Održavanje,
+Multiple Item prices.,Više cijena artikala,
+Received From,je primljen od,
+Write Off Difference Amount,Otpis razlike u iznosu,
+Closing Date,Datum zatvaranja,
+Cheque/Reference Date,Datum izvoda,
+Planned Qty,Planirana količina,
+Payment Date,Datum plaćanja,
+Additional Details,Dodatni detalji,
+Create Chart Of Accounts Based On,Kreiraj kontni plan prema,
+You can not change rate if BOM mentioned agianst any item,Не можете променити цену ако постоји Саставница за било коју ставку.
+Open To Do,Otvori To Do,
+Average Discount,Prosječan popust,
+Material Issue,Reklamacija robe,
+Billed Amt,Fakturisani iznos,
+Supplier Quotation {0} created,Ponuda dobavljaču {0} је kreirana,
+Not allowed to update stock transactions older than {0},Nije dozvoljeno mijenjati Promjene na zalihama starije od {0}
+Add Employees,Dodaj Zaposlenog,
+Setting up Employees,Podešavanja Zaposlenih,
+Warehouse not found in the system,Skladište nije pronađeno u sistemu,
+Attendance for employee {0} is already marked for this day,Prisustvo zaposlenog {0} је već označeno za ovaj dan,
+Employee relieved on {0} must be set as 'Left',"Zaposleni smijenjen na {0} mora biti označen kao ""Napustio"""
+ Shipping Bill Number,Broj isporuke,
+Lab Test Report,Izvještaj labaratorijskog testa,
+You cannot credit and debit same account at the same time,Не можете кредитирати и дебитовати исти налог у исто време.
+Customer Name,Naziv kupca,
+Current Address,Trenutna adresa,
+Upcoming Calendar Events,Predstojeći događaji u kalendaru,
+Make Payment via Journal Entry,Kreiraj uplatu kroz knjiženje,
+Paid,Plaćeno,
+Buying,Nabavka,
+Default Item Group,Podrazumijevana vrsta artikala,
+In Stock Qty,Na zalihama,
+Taxes and Charges Deducted (Company Currency),Umanjeni porezi i naknade (valuta preduzeća)
+Additional Costs,Dodatni troškovi,
+Pending Review,Čeka provjeru,
+Default Selling Cost Center,Podrazumijevani centar troškova,
+No Customers yet!,Još uvijek nema kupaca!
+Sales Return,Povraćaj prodaje,
+No Items added to cart,Nema dodatih artikala na računu,
+This is based on transactions against this Customer. See timeline below for details,Ovo je zasnovano na transkcijama ovog klijenta. Pogledajte vremensku liniju ispod za dodatne informacije,
+Make Timesheet,Kreiraj potrošeno vrijeme,
+Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Upozorenje: Prodajni nalog {0}već postoji veza sa porudžbenicom kupca {1}
+Healthcare Settings,Podešavanje klinike,
+Accounting Ledger,Analitička kartica,
+Total Outgoing Value,Ukupna vrijednost isporuke,
+Sales Order {0} is {1},Prodajni nalog {0} је {1}
+Automatically Set Serial Nos based on FIFO,Podesi automatski serijski broj da koristi FIFO,
+New Customers,Novi kupci,
+Pre Sales,Prije prodaje,
+POS Customer Group,POS grupa kupaca,
+Shopping Cart,Korpa sa sajta,
+Reserved for manufacturing,Rezervisana za proizvodnju,
+Pricing Rule Help,Pravilnik za cijene pomoć
+Ageing Range 2,Opseg dospijeća 2,
+Employee Benefits,Primanja Zaposlenih,
+POS Item Group,POS Vrsta artikala,
+Lead,Lead,
+Employee Settings,Podešavanja zaposlenih,
+View All Products,Pogledajte sve proizvode,
+Patient Medical Record,Medicinski karton pacijenta,
+Batch,Serija,
+Purchase Receipt,Prijem robe,
+Warranty Period (in days),Garantni rok (u danima)
+Customer database.,Korisnička baza podataka,
+Attendance Date,Datum prisustva,
+Notify Employee,Obavijestiti Zaposlenog,
+User ID not set for Employee {0},Korisnički ID nije podešen za Zaposlenog {0}
+Stock Projected Qty,Projektovana količina na zalihama,
+Make Payment,Kreiraj plaćanje,
+You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Ne možete obrisati fiskalnu godinu {0}. Fiskalna  {0} godina je označena kao trenutna u globalnim podešavanjima.
+{0} units of {1} needed in {2} to complete this transaction.,Željenu količinu {0} za artikal {1} je potrebno dodati na {2} da bi dovršili transakciju..
+Item-wise Sales Register,Prodaja po artiklima,
+Tax Rate,Poreska stopa,
+Remarks,Napomena,
+Sales,Prodaja,
+Pricing Rule,Pravilnik za cijene,
+Products Settings,Podešavanje proizvoda,
+Mobile,Mobilni,
+Price List Rate,Cijena,
+Discount Amount,Vrijednost popusta,
+Sales Invoice Trends,Trendovi faktura prodaje,
+You don't have enought Loyalty Points to redeem,Немате довољно Бодова Лојалности.
+Tax Breakup,Porez po pozicijama,
+Task,Zadatak,
+Add / Edit Prices,Dodaj / Izmijeni cijene,
+Item Prices,Cijene artikala,
+Salary Component,Компонента плате
+Customer's Purchase Order Date,Datum porudžbenice kupca,
+Country of Origin,Zemlja porijekla,
+Please select Employee Record first.,Molimo izaberite registar Zaposlenih prvo,
+Order Type,Vrsta porudžbine,
+Rate & Amount,Cijena i iznos sa rabatom,
+For Price List,Za cjenovnik,
+Tax ID,Poreski broj,
+WIP Warehouse,Wip skladište,
+Itemwise Recommended Reorder Level,Pregled preporučenih nivoa dopune,
+{0} against Bill {1} dated {2},{0} veza sa računom {1} na datum {2}
+You are not authorized to set Frozen value,Немате дозволу да постављате замрзнуту вредност
+Requested Items To Be Ordered,Tražene stavke za isporuku,
+Unmarked Attendance,Neobilježeno prisustvo,
+Sales Order {0} is not submitted,Prodajni nalog {0} nije potvrđen,
+Default Material Request Type,Podrazumijevani zahtjev za tip materijala,
+Sales Pipeline,Prodajna linija,
+Already completed,Već završen,
+Ordered Qty,Poručena kol,
+Sales Details,Detalji prodaje,
+Navigating,Navigacija,
+Your Products or Services,Vaši artikli ili usluge,
+CRM,CRM,
+The Brand,Brend,
+Quotation {0} is cancelled,Ponuda {0} je otkazana,
+Item Code,Šifra artikla,
+Customer Mobile No,Broj telefona kupca,
+Reorder Qty,Kol. za dopunu,
+Move Item,Premještanje artikala,
+Buying Settings,Podešavanja nabavke,
+From Employee,Od Zaposlenog,
+Fleet Manager,Menadžer transporta,
+Stock Levels,Nivoi zalihe,
+Rate With Margin (Company Currency),Cijena sa popustom (Valuta preduzeća)
+Closing (Cr),Saldo (Po)
+Product Bundle,Sastavnica,
+Sales and Returns,Prodaja i povraćaji,
+Sync Master Data,Sinhronizuj podatke iz centrale,
+Sales Person Name,Ime prodajnog agenta,
+Purchase Receipts,Prijemi robe,
+Customizing Forms,Prilagođavanje formi,
+Attendance for employee {0} is already marked,Prisustvo zaposlenog {0} je već označeno,
+% Complete Method,% metod vrednovanja završetka projekta,
+Overdue,Istekao,
+Posting Time,Vrijeme izrade računa,
+Purchase Receipt No,Broj prijema robe,
+Expected End Date,Očekivani datum završetka,
+Expected End Date can not be less than Expected Start Date,Očekivani datum završetka ne može biti manji od očekivanog dana početka,
+Customer Primary Contact,Primarni kontakt kupca,
+Expected Start Date,Očekivani datum početka,
+Credit Limit,Kreditni limit,
+Item Tax,Porez,
+Selling,Prodaja,
+Customer Contact,Kontakt kupca,
+Item {0} does not exist,Artikal {0} ne postoji,
+Add Users,Dodaj korisnike,
+Select Serial Numbers,Izaberite serijske brojeve,
+Payment Entry,Uplate,
+In Words,Riječima,
+Employee record is created using selected field. ,Izvještaj o Zaposlenom se kreira korišćenjem izabranog polja.
+Serial No {0} does not belong to Delivery Note {1},Serijski broj {0} ne pripada otpremnici {1}
+Support,Podrška,
+Get Sales Orders,Pregledaj prodajne naloge,
+Stock Ledger Entry,Unos zalihe robe,
+Gantt chart of all tasks.,Gantov grafikon svih zadataka,
+Price List Rate (Company Currency),Cijena (Valuta preduzeća)
+Address Name,Naziv adrese,
+Another Sales Person {0} exists with the same Employee id,Postoji još jedan Prodavac {0} sa istim ID zaposlenog,
+Item Group Name,Naziv vrste artikala,
+A Customer Group exists with same name please change the Customer name or rename the Customer Group,Isto ime grupe kupca već postoji. Promijenite ime kupca ili izmijenite grupu kupca,
+Warning: Another {0} # {1} exists against stock entry {2},Upozorenje: Još jedan  {0} # {1} postoji u vezanom Unosu zaliha {2}
+Suplier,Dobavljač
+Has Serial No,Ima serijski broj,
+Employee {0} on Half day on {1},Zaposleni {0} na pola radnog vremena {1}
+Difference Amount (Company Currency),Razlika u iznosu (Valuta)
+Add Serial No,Dodaj serijski broj,
+Company and Accounts,Preduzeće i računi,
+Current Address Is,Trenutna adresa je,
+Unallocated Amount,Nepovezani iznos,
+Show zero values,Prikaži vrijednosti sa nulom,
+Address and Contact,Adresa i kontakt,
+Supplier-Wise Sales Analytics,Analiza Dobavljačeve pametne prodaje,
+Payment Entry is already created,Uplata je već kreirana,
+Item,Artikal,
+Unpaid,Neplaćen,
+Net Rate,Neto cijena sa rabatom,
+Project User,Projektni user,
+Customer Items,Proizvodi kupca,
+Item {0} is cancelled,Stavka {0} je otkazana,
+Balance Value,Stanje vrijed.
+Sales Order required for Item {0},Prodajni nalog je obavezan za artikal {0}
+Patient,Pacijent,
+Default Target Warehouse,Prijemno skladište,
+Voucher No,Br. dokumenta,
+Attendance has been marked successfully.,Prisustvo je uspješno obilježeno.
+Serial No {0} created,Serijski broj {0} kreiran,
+Asset,Osnovna sredstva,
+Received Amount,Iznos uplate,
+You cannot edit root node.,Не можете уређивати коренски чвор.
+Sales Funnel,Prodajni lijevak,
+Payment Due Date,Datum dospijeća fakture,
+Consultation,Pregled,
+Related,Povezan,
+Warehouse Name,Naziv skladišta,
+Customer / Item Name,Kupac / Naziv proizvoda,
+Total Billed Amount,Ukupno fakturisano,
+In Value,Prijem vrije.
+Employees Email Id,ID email Zaposlenih,
+Tree Type,Tip stabla,
+Update Rate and Availability,Izmijenite cijenu i dostupnost,
+Supplier Quotation,Ponuda dobavljača,
+Quantity and Warehouse,Količina i skladište,
+Taxes and Charges Added,Porezi i naknade dodate,
+Warehouses,Skladišta,
+All Customer Contact,Svi kontakti kupca,
+Ledger,Skladišni karton,
+Quotation Lost Reason,Razlog gubitka ponude,
+Return Against Purchase Invoice,Povraćaj u vezi sa Fakturom nabavke,
+Brand Name,Naziv brenda,
+Stock,Zalihe,
+Customer Group Name,Naziv grupe kupca,
+Is Sales Item,Da li je prodajni artikal,
+Invoiced Amount,Fakturisano,
+Edit Posting Date and Time,Izmijeni datum i vrijeme dokumenta,
+Inactive Customers,Neaktivni kupci,
+Stock Entry Detail,Detalji unosa zaliha,
+Accounting Details,Računovodstveni detalji,
+Stock Manager,Menadžer zaliha,
+As on Date,Na datum,
+Is Cancelled,Je otkazan,
+Setup Series,Podešavanje tipa dokumenta,
+Point of Sale,Kasa,
+Invoice No,Broj fakture,
+Purchase Receipt Item,Stavka Prijema robe,
+Invoices,Fakture,
+Task Progress,% završenosti zadataka,
+Employee Attendance Tool,Alat za prisustvo Zaposlenih,
+Payment Days,Dana za plaćanje,
+Recruitment,Zapošljavanje,
+Taxes and Charges Calculation,Izračun Poreza,
+For Employee,Za Zaposlenog,
+Terms and Conditions Template,Uslovi i odredbe šablon,
+Change,Kusur,
+Stock Entry {0} created,Unos zaliha {0} je kreiran,
+Search Item (Ctrl + i),Pretraga artikala (Ctrl + i)
+View in Cart,Pogledajte u korpi,
+Item Price updated for {0} in Price List {1},Cijena artikla je izmijenjena {0} u cjenovniku {1}
+Discount,Popust,
+Net Weight UOM,Neto težina  JM,
+Party Type,Tip partije,
+Sales Order Required,Prodajni nalog je obavezan,
+Search Item,Pretraži artikal,
+Delivered Items To Be Billed,Nefakturisana isporučena roba,
+Debit,Duguje,
+Date TIme,Datum i vrijeme,
+Payment Document,Dokument za plaćanje,
+You can not enter current voucher in 'Against Journal Entry' column,"Неможете унети тренутни ваучер у колону ""На основу ставке у журналу"""
+In Words (Company Currency),Riječima (valuta kompanije)
+Purchase Receipt Trends,Trendovi prijema robe,
+Employee Leave Approver,Odobreno odsustvo Zaposlenog,
+Fiscal Year {0} does not exist,Fiskalna godina {0} ne postoji,
+Accepted Warehouse,Prihvaćeno skladište,
+Income Account,Račun prihoda,
+Account Balance,Knjigovodstveno stanje,
+'Expected Start Date' can not be greater than 'Expected End Date',Očekivani datum početka ne može biti veći od očekivanog datuma završetka,
+Employee Emails,Elektronska pošta Zaposlenog,
+Opening Qty,Početna količina,
+Reorder level based on Warehouse,Nivo dopune u zavisnosti od skladišta,
+To Warehouse,U skladište,
+Is Group,Je grupa,
+Contact Person,Kontakt osoba,
+Item Code for Suppliers,Dobavljačeva šifra,
+Return / Debit Note,Povraćaj / knjižno zaduženje,
+Request for Quotation Supplier,Zahtjev za ponudu dobavljača,
+LeaderBoard,Tabla,
+Lab Test Groups,Labaratorijske grupe,
+Training Result Employee,Rezultati obuke Zaposlenih,
+Invoice Details,Detalji fakture,
+Banking and Payments,Bakarstvo i plaćanja,
+Employee Name,Ime Zaposlenog,
+Active Leads / Customers,Активни Леадс / Kupci,
+Accounting,Računovodstvo,
+Party Name,Ime partije,
+Manufacture,Proizvodnja,
+New task,Novi zadatak,
+Accounts Payable,Obaveze prema dobavljačima,
+Shipping Address,Adresa isporuke,
+Outstanding Amount,Preostalo za uplatu,
+New Warehouse Name,Naziv novog skladišta,
+Billed Amount,Fakturisani iznos,
+Balance Qty,Stanje zalihe,
+Item Shortage Report,Izvještaj o negativnim zalihama,
+Transaction reference no {0} dated {1},Broj izvoda {0} na datum {1}
+Make Sales Order,Kreiraj prodajni nalog,
+Items,Artikli,
+Employees working on a holiday,Zaposleni koji rade za vrijeme praznika,
+Allocate Payment Amount,Poveži uplaćeni iznos,
+Patient ID,ID pacijenta,
+Printed On,Datum i vrijeme štampe,
+Debit To,Zaduženje za,
+Global Settings,Globalna podešavanja,
+Make Employee,Keriraj Zaposlenog,
+Atleast one warehouse is mandatory,Minimum jedno skladište je obavezno,
+Price List Name,Naziv cjenovnika,
+Journal Entry for Scrap,Knjiženje rastura i loma,
+Website Warehouse,Skladište web sajta,
+Customer's Item Code,Šifra kupca,
+Supplier,Dobavljači,
+Additional Discount Amount,Iznos dodatnog popusta,
+Project Start Date,Datum početka projekta,
+Student,Student,
+Suplier Name,Naziv dobavljača,
+In Qty,Prijem količine,
+Selling Rate,Prodajna cijena,
+Import Successful!,Uvoz uspješan!
+Stock cannot be updated against Delivery Note {0},Zaliha se ne može promijeniti jer je vezana sa otpremnicom {0}
+You are in offline mode. You will not be able to reload until you have network.,Радите без интернета. Нећете моћи да учитате страницу док се не повежете.
+Form View,Prikaži kao formu,
+Shortage Qty,Manjak kol.
+Hour,Sat,
+Item Group Tree,Stablo vrste artikala,
+Update Stock,Ažuriraj zalihu,
+Target Warehouse,Ciljno skladište,
+Delivery Note Trends,Trendovi Otpremnica,
+Default Source Warehouse,Izdajno skladište,
+"{0}: Employee email not found, hence email not sent","{0}: Email zaposlenog nije pronađena, stoga email nije poslat"
+All Warehouses,Sva skladišta,
+Difference Amount,Razlika u iznosu,
+User Remark,Korisnička napomena,
+Quotation Message,Ponuda - poruka,
+% Received,% Primljeno,
+Stock Entry,Unos zaliha,
+Sales Price List,Prodajni cjenovnik,
+Avg. Selling Rate,Prosječna prodajna cijena,
+End of Life,Kraj proizvodnje,
+Payment Type,Vrsta plaćanja,
+Default Customer Group,Podrazumijevana grupa kupaca,
+Party,Partija,
+Total Stock Summary,Ukupan pregled zalihe,
+Net Total (Company Currency),Ukupno bez PDV-a (Valuta preduzeća)
+Patient Name,Ime pacijenta,
+Write Off,Otpisati,
+Delivery Note Message,Poruka na otpremnici,
+"Cannot delete Serial No {0}, as it is used in stock transactions","Ne može se obrisati serijski broj {0}, dok god se nalazi u dijelu Promjene na zalihama"
+Delivery Note {0} is not submitted,Otpremnica {0} nije potvrđena,
+New Employee,Novi Zaposleni,
+Customers in Queue,Kupci na čekanju,
+Price List Currency,Valuta Cjenovnika,
+Applicable To (Employee),Primjenljivo na (zaposlene)
+Project Manager,Projektni menadzer,
+Accounts Receivable,Potraživanja od kupaca,
+Rate,Cijena sa popustom,
+View Task,Pogledaj zadatak,
+Employee Education,Obrazovanje Zaposlenih,
+Expense,Rashod,
+Newsletters,Newsletter-i,
+Select Supplier Address,Izaberite adresu dobavljača,
+Price List {0} is disabled or does not exist,Cjenovnik {0} je zaključan ili ne postoji,
+Billing Address Name,Naziv adrese za naplatu,
+Add Item,Dodaj stavku,
+All Customer Groups,Sve grupe kupca,
+Employee Birthday,Rođendan Zaposlenih,
+Total Billed Amount (via Sales Invoices),Ukupno fakturisano (putem fakture prodaje)
+Weight UOM,JM Težina,
+Stock Qty,Zaliha,
+Return Against Delivery Note,Povraćaj u vezi sa otpremnicom,
+Ageing Range 1,Opseg dospijeća 1,
+Incoming Rate,Nabavna cijena,
+Timesheets,Potrošnja vremena,
+Attendance From Date,Datum početka prisustva,
+Stock Items,Artikli na zalihama,
+New Cart,Nova korpa,
+Opening Value,Početna vrijednost,
+"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Podešavanje stanja na {0}, pošto Zaposleni koji se priključio Prodavcima nema koririsnički ID {1}"
+Import Attendance,Uvoz prisustva,
+Analytics,Analitika,
+Bank Balance,Stanje na računu,
+Employee Number,Broj Zaposlenog,
+Rate and Amount,Cijena i vrijednost sa popustom,
+'Total','Ukupno bez PDV-a'
+Total Taxes and Charges,Porez,
+No active or default Salary Structure found for employee {0} for the given dates,Nisu pronađene aktivne ili podrazumjevane strukture plate za Zaposlenog {0} za dati period,
+Supplier Part Number,Dobavljačeva šifra,
+Project Task,Projektni zadatak,
+Parent Item Group,Nadređena Vrsta artikala,
+Mark Attendance,Označi prisustvo,
+{0} created,Kreirao je korisnik {0}
+Advance Paid,Avansno plačanje,
+Projected,Projektovana količina na zalihama,
+Reorder Level,Nivo dopune,
+Customer / Lead Address,Kupac / Adresa lead-a,
+Default Buying Price List,Podrazumijevani Cjenovnik,
+Qty,Kol,
+General,Opšte,
+Default Payable Accounts,Podrazumijevani nalog za plaćanje,
+Rate: {0},Cijena: {0}
+Write Off Amount,Zaokruženi iznos,
+Total Outstanding Amount,Preostalo za plaćanje,
+Not Paid and Not Delivered,Nije plaćeno i nije isporučeno,
+Planned,Planirano,
+Total Amount,Ukupan iznos,
+Please select Price List,Izaberite cjenovnik,
+Item Serial No,Seriski broj artikla,
+Customer Service,Usluga kupca,
+Working,U toku,
+Stock User,Korisnik zaliha,
+General Ledger,Glavna knjiga,
+Received Date,Datum prijema,
+Project master.,Projektni master,
+Valid From,Važi od,
+Purchase Order Trends,Trendovi kupovina,
+In Words will be visible once you save the Quotation.,Sačuvajte Predračun da bi Ispis slovima bio vidljiv,
+Projected Qty,Projektovana količina,
+Customer Addresses And Contacts,Kontakt i adresa kupca,
+Employee name and designation in print,Ime i pozicija Zaposlenog,
+For Warehouse,Za skladište,
+Purchase Price List,Nabavni cjenovnik,
+Accounts Payable Summary,Pregled obaveze prema dobavljačima,
+Delivery Notes {0} must be cancelled before cancelling this Sales Order,Otpremnice {0} moraju biti otkazane prije otkazivanja prodajnog naloga,
+Total Payment,Ukupno plaćeno,
+POS Settings,POS podešavanja,
+Buying Amount,Iznos nabavke,
+Valuation Rate,Prosječna nab. cijena,
+Project Id,ID Projekta,
+Invoice Copy,Kopija Fakture,
+You have been invited to collaborate on the project: {0},Позвани сте да сарађујете на пројекту: {0}
+Purchase Order,Porudžbenica,
+Rate With Margin,Cijena sa popustom,
+"Search by item code, serial number, batch no or barcode","Pretraga po šifri, serijskom br. ili bar kodu"
+Voucher Type,Vrsta dokumenta,
+Serial No {0} has already been received,Serijski broj {0} je već primljen,
+Data Import and Export,Uvoz i izvoz podataka,
+Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Ukupan avns({0}) na porudžbini {1} ne može biti veći od Ukupnog iznosa ({2})
+% Ordered,%  Poručenog,
+Price List not selected,Cjenovnik nije odabran,
+Apply Discount On,Primijeni popust na,
+Total Projected Qty,Ukupna projektovana količina,
+Shipping Rule Condition,Uslovi  pravila nabavke,
+Opening Stock Balance,Početno stanje zalihe,
+Customer Credit Balance,Kreditni limit kupca,
+No address added yet.,Adresa još nije dodata.
+Net Total,Ukupno bez PDV-a,
+Total Qty,Ukupna kol.
+Return,Povraćaj,
+Delivery Warehouse,Skladište dostave,
+Total (Company Currency),Ukupno bez PDV-a (Valuta)
+Change Amount,Kusur,
+Opportunity,Prilika,
+Fully Delivered,Kompletno isporučeno,
+Leave blank if considered for all employee types,Ostavite prazno ako se podrazumijeva za sve tipove Zaposlenih,
+Disc,Popust,
+Default Price List,Podrazumijevani cjenovnik,
+Journal Entry,Knjiženje,
+Apply Additional Discount On,Primijeni dodatni popust na,
+This is based on transactions against this Supplier. See timeline below for details,Ovo je zasnovano na transkcijama ovog dobavljača. Pogledajte vremensku liniju ispod za dodatne informacije,
+90-Above,Iznad 90 dana,
+You have already assessed for the assessment criteria {}.,Већ сте оценили за критеријум оцењивања {}.
+Serial Numbers in row {0} does not match with Delivery Note,Serijski broj na poziciji {0} se ne poklapa sa otpremnicom,
+New Contact,Novi kontakt,
+Returns,Povraćaj,
+Delivery To,Isporuka za,
+Project Value,Vrijednost Projekta,
+Parent Warehouse,Nadređeno skladište,
+Make Sales Invoice,Kreiraj fakturu prodaje,
+Del,Obriši,
+Select Warehouse...,Izaberite skladište...
+Invoice/Journal Entry Details,Faktura / Detalji knjiženja,
+Projected Quantity as Source,Projektovana izvorna količina,
+Manufacturing User,Korisnik u proizvodnji,
+Create Users,Kreiraj korisnike,
+Price,Cijena,
+Out Qty,Izdavanje Kol.
+Employee,Zaposleni,
+Project activity / task.,Projektna aktivnost / zadatak,
+Reserved Warehouse in Sales Order / Finished Goods Warehouse,Rezervisano skladište u Prodajnom nalogu / Skladište gotovog proizvoda,
+Physician,Ljekar,
+Quantity,Količina,
+Purchase Receipt Required,Prijem robe je obavezan,
+Currency is required for Price List {0},Valuta je obavezna za Cjenovnik {0}
+Out Value,Izdavanje vrije.
+Customer Group,Grupa kupaca,
+You are not authorized to add or update entries before {0},Немате дозволу да додајете или ажурирате ставке пре {0}
+Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Skladište se jedino može promijeniti u dijelu Unos zaliha / Otpremnica / Prijem robe,
+Request for Quotations,Zahtjev za ponude,
+Learn,Naučite,
+Employee Detail,Detalji o Zaposlenom,
+Ignore Pricing Rule,Zanemari pravilnik o cijenama,
+Additional Discount,Dodatni popust,
+Cheque/Reference No,Broj izvoda,
+Attendance date can not be less than employee's joining date,Datum prisustva ne može biti raniji od datuma ulaska zaposlenog,
+Box,Kutija,
+Total Allocated Amount,Ukupno povezani iznos,
+All Addresses.,Sve adrese,
+Opening Balances,Početna stanja,
+Users and Permissions,Korisnici i dozvole,
+"You can only plan for upto {0} vacancies and budget {1} \
 				for {2} as per staffing plan {3} for parent company {4}.",Можете планирати до {0} слободна места и буџетирати {1} \ за {2} по плану особља {3} за матичну компанију {4}.
-apps/erpnext/erpnext/public/js/event.js +19,Add Customers,Dodaj kupce
-DocType: Employee External Work History,Employee External Work History,Istorijat o radu van preduzeća za Zaposlenog
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,Otpremite robu prvo
-DocType: Lead,From Customer,Od kupca
-DocType: Item,Maintain Stock,Vođenje zalihe
-DocType: Sales Invoice Item,Sales Order Item,Pozicija prodajnog naloga
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,Datum početka prisustva i prisustvo do danas su obavezni
-apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +73,Reserved Qty,Rezervisana kol.
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1768,Not items found,Ništa nije pronađeno
-DocType: Item,Copy From Item Group,Kopiraj iz vrste artikala
-DocType: Journal Entry,Total Amount in Words,Ukupan iznos riječima
-DocType: Purchase Taxes and Charges,On Net Total,Na ukupno bez PDV-a
-apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}% završen
-apps/erpnext/erpnext/accounts/utils.py +74,{0} {1} not in any active Fiscal Year.,{0} {1} se ne nalazi u aktivnim poslovnim godinama.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +533,Quick Journal Entry,Brzo knjiženje
-DocType: Sales Order,Partly Delivered,Djelimično isporučeno
-apps/erpnext/erpnext/stock/doctype/item/item.js +29,Balance,Pregled zalihe
-DocType: Purchase Invoice Item,Quality Inspection,Provjera kvaliteta
-apps/erpnext/erpnext/config/accounts.py +83,Accounting Statements,Računovodstveni iskazi
-apps/erpnext/erpnext/stock/get_item_details.py +416,Item Price added for {0} in Price List {1},Cijena je dodata na artiklu {0} iz cjenovnika {1}
-DocType: Project Type,Projects Manager,Projektni menadžer
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +102,Quotation {0} not of type {1},Ponuda {0} ne propada {1}
-apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Svi proizvodi ili usluge.
-DocType: Purchase Invoice,Rounded Total,Zaokruženi ukupan iznos
-DocType: Request for Quotation Supplier,Download PDF,Preuzmi PDF
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +970,Quotation,Ponuda
-DocType: Lead,Mobile No.,Mobilni br.
-DocType: Item,Has Variants,Ima varijante
-DocType: Price List Country,Price List Country,Zemlja cjenovnika
-apps/erpnext/erpnext/controllers/accounts_controller.py +180,Due Date is mandatory,Datum dospijeća je obavezan
-apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7,Cart,Korpa
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Promjene na zalihama prije {0} su zamrznute
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +52,Employee {0} is not active or does not exist,Zaposleni {0} nije aktivan ili ne postoji
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,Унели сте дупликате. Молимо проверите и покушајте поново.
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +271,Closing (Dr),Saldo (Du)
-DocType: Sales Invoice,Product Bundle Help,Sastavnica Pomoć
-apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py +401,Total {0} ({1}),Ukupno bez PDV-a {0} ({1})
-DocType: Sales Partner,Address & Contacts,Adresa i kontakti
-apps/erpnext/erpnext/controllers/accounts_controller.py +377, or ,ili
-apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Zahtjev za ponudu
-apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Standardna prodaja
-DocType: Department,Expense Approver,Odobravatalj troškova
-DocType: Purchase Invoice,Supplier Invoice Details,Detalji sa fakture dobavljača
-DocType: Purchase Order,To Bill,Za fakturisanje
-apps/erpnext/erpnext/projects/doctype/project/project.js +54,Gantt Chart,Gant dijagram
-DocType: Bin,Requested Quantity,Tražena količina
-DocType: Company,Chart Of Accounts Template,Templejt za kontni plan
-DocType: Employee Attendance Tool,Marked Attendance,Označeno prisustvo
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +302,Please set a default Holiday List for Employee {0} or Company {1},Molimo podesite podrazumjevanu listu praznika za Zaposlenog {0} ili Preduzeće {1}
-apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Pending Amount,Iznos na čekanju
-DocType: Payment Entry Reference,Supplier Invoice No,Broj fakture dobavljača
-apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Globalna podešavanja za cjelokupan proces proizvodnje.
-DocType: Stock Entry,Material Transfer for Manufacture,Пренос robe za proizvodnju
-apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16,Primary Contact Details,Detalji o primarnom kontaktu
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +28,Ref,Vezni dokument
-DocType: Account,Accounts,Računi
-,Requested,Tražena
-apps/erpnext/erpnext/controllers/buying_controller.py +503,{0} {1} is cancelled or closed,{0} {1} je otkazan ili zatvoren
-DocType: Request for Quotation Item,Request for Quotation Item,Zahtjev za stavku sa ponude
-DocType: Homepage,Products,Proizvodi
-DocType: Patient Appointment,Check availability,Provjeri dostupnost
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +339,Timesheet created:,Potrošeno vrijeme je kreirano:
-apps/erpnext/erpnext/utilities/activation.py +135,Create Employee Records,Kreirati izvještaj o Zaposlenom
-apps/erpnext/erpnext/public/js/setup_wizard.js +118,"e.g. ""Build tools for builders""","npr. ""Izrada alata za profesionalce"""
-apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.js +7,Make Invoice,Kreiraj Fakturu
-DocType: Purchase Invoice,Is Paid,Je plaćeno
-DocType: Manufacturing Settings,Material Transferred for Manufacture,Prenešena roba za proizvodnju
-,Ordered Items To Be Billed,Poručeni artikli za fakturisanje
-apps/erpnext/erpnext/config/education.py +230,Other Reports,Ostali izvještaji
-DocType: Blanket Order,Purchasing,Kupovina
-apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',"Не можете обрисати ""Спољни"" тип пројекта."
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +990,Delivery Note,Otpremnice
-DocType: Sales Order,In Words will be visible once you save the Sales Order.,U riječima će biti vidljivo tek kada sačuvate prodajni nalog.
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +488,Show Salary Slip,Прикажи одсечак плате
-apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Troškovi aktivnosti po zaposlenom
-DocType: Journal Entry Account,Sales Order,Prodajni nalog
-DocType: Stock Entry,Customer or Supplier Details,Detalji kupca ili dobavljača
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,Prodaja
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +407,Salary Slip of employee {0} already created for time sheet {1},Isplatna lista Zaposlenog {0} kreirana je već za raspored {1}
-DocType: Purchase Invoice,Additional Discount Percentage,Dodatni procenat popusta
-DocType: Additional Salary,HR User,Korisnik za ljudske resure
-apps/erpnext/erpnext/config/stock.py +28,Stock Reports,Izvještaji zaliha robe
-DocType: Sales Invoice,Return Against Sales Invoice,Povraćaj u vezi sa Fakturom prodaje
-DocType: Asset,Naming Series,Vrste dokumenta
-,Monthly Attendance Sheet,Mjesečni list prisustva
-,Stock Ledger,Skladišni karton
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +235,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Faktura {0} mora biti otkazana prije otkazivanja ovog prodajnog naloga
-DocType: Email Digest,New Quotations,Nove ponude
-apps/erpnext/erpnext/projects/doctype/project/project.js +98,Save the document first.,Prvo sačuvajte dokument
-DocType: Salary Slip,Employee Loan,Zajmovi Zaposlenih
-DocType: Item,Units of Measure,Jedinica mjere
-DocType: Antibiotic,Healthcare,Klinika
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52,Actual qty in stock,Trenutna količina na zalihama
-DocType: Material Request Plan Item,Actual Qty,Trenutna kol.
+Add Customers,Dodaj kupce,
+Employee External Work History,Istorijat o radu van preduzeća za Zaposlenog,
+Please Delivery Note first,Otpremite robu prvo,
+From Customer,Od kupca,
+Maintain Stock,Vođenje zalihe,
+Sales Order Item,Pozicija prodajnog naloga,
+Attendance From Date and Attendance To Date is mandatory,Datum početka prisustva i prisustvo do danas su obavezni,
+Reserved Qty,Rezervisana kol.
+Not items found,Ništa nije pronađeno,
+Copy From Item Group,Kopiraj iz vrste artikala,
+Total Amount in Words,Ukupan iznos riječima,
+On Net Total,Na ukupno bez PDV-a,
+{0}% Complete,{0}% završen,
+{0} {1} not in any active Fiscal Year.,{0} {1} se ne nalazi u aktivnim poslovnim godinama.
+Quick Journal Entry,Brzo knjiženje,
+Partly Delivered,Djelimično isporučeno,
+Balance,Pregled zalihe,
+Quality Inspection,Provjera kvaliteta,
+Accounting Statements,Računovodstveni iskazi,
+Item Price added for {0} in Price List {1},Cijena je dodata na artiklu {0} iz cjenovnika {1}
+Projects Manager,Projektni menadžer,
+Quotation {0} not of type {1},Ponuda {0} ne propada {1}
+All Products or Services.,Svi proizvodi ili usluge.
+Rounded Total,Zaokruženi ukupan iznos,
+Download PDF,Preuzmi PDF,
+Quotation,Ponuda,
+Mobile No.,Mobilni br.
+Has Variants,Ima varijante,
+Price List Country,Zemlja cjenovnika,
+Due Date is mandatory,Datum dospijeća je obavezan,
+Cart,Korpa,
+Stock transactions before {0} are frozen,Promjene na zalihama prije {0} su zamrznute,
+Employee {0} is not active or does not exist,Zaposleni {0} nije aktivan ili ne postoji,
+You have entered duplicate items. Please rectify and try again.,Унели сте дупликате. Молимо проверите и покушајте поново.
+Closing (Dr),Saldo (Du)
+Product Bundle Help,Sastavnica Pomoć
+Total {0} ({1}),Ukupno bez PDV-a {0} ({1})
+Address & Contacts,Adresa i kontakti,
+ or ,ili,
+Request for quotation.,Zahtjev za ponudu,
+Standard Selling,Standardna prodaja,
+Expense Approver,Odobravatalj troškova,
+Supplier Invoice Details,Detalji sa fakture dobavljača,
+To Bill,Za fakturisanje,
+Gantt Chart,Gant dijagram,
+Requested Quantity,Tražena količina,
+Chart Of Accounts Template,Templejt za kontni plan,
+Marked Attendance,Označeno prisustvo,
+Please set a default Holiday List for Employee {0} or Company {1},Molimo podesite podrazumjevanu listu praznika za Zaposlenog {0} ili Preduzeće {1}
+Pending Amount,Iznos na čekanju,
+Supplier Invoice No,Broj fakture dobavljača,
+Global settings for all manufacturing processes.,Globalna podešavanja za cjelokupan proces proizvodnje.
+Material Transfer for Manufacture,Пренос robe za proizvodnju,
+Primary Contact Details,Detalji o primarnom kontaktu,
+Ref,Vezni dokument,
+Accounts,Računi,
+Requested,Tražena,
+{0} {1} is cancelled or closed,{0} {1} je otkazan ili zatvoren,
+Request for Quotation Item,Zahtjev za stavku sa ponude,
+Products,Proizvodi,
+Check availability,Provjeri dostupnost,
+Timesheet created:,Potrošeno vrijeme je kreirano:
+Create Employee Records,Kreirati izvještaj o Zaposlenom,
+"e.g. ""Build tools for builders""","npr. ""Izrada alata za profesionalce"""
+Make Invoice,Kreiraj Fakturu,
+Is Paid,Je plaćeno,
+Material Transferred for Manufacture,Prenešena roba za proizvodnju,
+Ordered Items To Be Billed,Poručeni artikli za fakturisanje,
+Other Reports,Ostali izvještaji,
+Purchasing,Kupovina,
+You cannot delete Project Type 'External',"Не можете обрисати ""Спољни"" тип пројекта."
+Delivery Note,Otpremnice,
+In Words will be visible once you save the Sales Order.,U riječima će biti vidljivo tek kada sačuvate prodajni nalog.
+Show Salary Slip,Прикажи одсечак плате
+Activity Cost per Employee,Troškovi aktivnosti po zaposlenom,
+Sales Order,Prodajni nalog,
+Customer or Supplier Details,Detalji kupca ili dobavljača,
+Sell,Prodaja,
+Salary Slip of employee {0} already created for time sheet {1},Isplatna lista Zaposlenog {0} kreirana je već za raspored {1}
+Additional Discount Percentage,Dodatni procenat popusta,
+HR User,Korisnik za ljudske resure,
+Stock Reports,Izvještaji zaliha robe,
+Return Against Sales Invoice,Povraćaj u vezi sa Fakturom prodaje,
+Naming Series,Vrste dokumenta,
+Monthly Attendance Sheet,Mjesečni list prisustva,
+Stock Ledger,Skladišni karton,
+Sales Invoice {0} must be cancelled before cancelling this Sales Order,Faktura {0} mora biti otkazana prije otkazivanja ovog prodajnog naloga,
+New Quotations,Nove ponude,
+Save the document first.,Prvo sačuvajte dokument,
+Employee Loan,Zajmovi Zaposlenih,
+Units of Measure,Jedinica mjere,
+Healthcare,Klinika,
+Actual qty in stock,Trenutna količina na zalihama,
+Actual Qty,Trenutna kol.
diff --git a/erpnext/translations/tr.csv b/erpnext/translations/tr.csv
index 69cdc2e..4dd613e 100644
--- a/erpnext/translations/tr.csv
+++ b/erpnext/translations/tr.csv
@@ -3472,7 +3472,6 @@
 Conditions,Koşullar,
 County,Kontluk,
 Day of Week,Haftanın günü,
-"Dear System Manager,Sevgili Sistem Yöneticisi,",
 Default Value,Varsayılan Değer,
 Email Group,E-posta Grubu,
 Email Settings,E-posta Ayarları,
@@ -9935,7 +9934,7 @@
 Customize Print Formats,Baskı Biçimlerini Özelleştirin,
 Generate Custom Reports,Özel Raporlar Oluşturun,
 Partly Paid,Kısmen Ödenmiş,
-Partly Paid and Discounted,Kısmen Ödenmiş ve İndirimli
+Partly Paid and Discounted,Kısmen Ödenmiş ve İndirimli,
 Fixed Time,Sabit Süre,
 Loan Write Off,Kredi İptali,
 Returns,İadeler,
diff --git a/erpnext/translations/zh-TW.csv b/erpnext/translations/zh-TW.csv
index c30dd72..22fd9ee 100644
--- a/erpnext/translations/zh-TW.csv
+++ b/erpnext/translations/zh-TW.csv
@@ -1,1116 +1,1116 @@
-DocType: Accounting Period,Period Name,期間名稱
-DocType: Employee,Salary Mode,薪酬模式
-DocType: Patient,Divorced,離婚
-DocType: Support Settings,Post Route Key,郵政路線密鑰
-DocType: Buying Settings,Allow Item to be added multiple times in a transaction,允許項目在一個交易中被多次新增
-apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,材質訪問{0}之前取消此保修索賠取消
-apps/erpnext/erpnext/config/education.py +118,Assessment Reports,評估報告
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19,Consumer Products,消費類產品
-DocType: Supplier Scorecard,Notify Supplier,通知供應商
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.js +52,Please select Party Type first,請選擇黨第一型
-DocType: Item,Customer Items,客戶項目
-DocType: Project,Costing and Billing,成本核算和計費
-apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +43,Advance account currency should be same as company currency {0},預付科目貨幣應與公司貨幣{0}相同
-DocType: QuickBooks Migrator,Token Endpoint,令牌端點
-apps/erpnext/erpnext/accounts/doctype/account/account.py +55,Account {0}: Parent account {1} can not be a ledger,科目{0}：上層科目{1}不能是總帳
-DocType: Item,Publish Item to hub.erpnext.com,發布項目hub.erpnext.com
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +270,Cannot find active Leave Period,找不到有效的休假期
-apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +22,Evaluation,評估
-DocType: Item,Default Unit of Measure,預設的計量單位
-DocType: SMS Center,All Sales Partner Contact,所有的銷售合作夥伴聯絡
-DocType: Department,Leave Approvers,休假審批人
-DocType: Employee,Bio / Cover Letter,自傳/求職信
-DocType: Patient Encounter,Investigations,調查
-DocType: Restaurant Order Entry,Click Enter To Add,點擊輸入要添加
-apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py +29,"Missing value for Password, API Key or Shopify URL",缺少密碼，API密鑰或Shopify網址的值
-apps/erpnext/erpnext/public/js/setup_wizard.js +243,All Accounts,所有科目
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py +15,Cannot transfer Employee with status Left,無法轉移狀態為左的員工
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +216,"Stopped Production Order cannot be cancelled, Unstop it first to cancel",停止生產訂單無法取消，首先Unstop它取消
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +338,Do you really want to scrap this asset?,難道你真的想放棄這項資產？
-DocType: Drug Prescription,Update Schedule,更新時間表
-apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44,Select Default Supplier,選擇默認供應商
-apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +26,Show Employee,顯示員工
-DocType: Exchange Rate Revaluation Account,New Exchange Rate,新匯率
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +38,Currency is required for Price List {0},價格表{0}需填入貨幣種類
-DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,*將被計算在該交易。
-DocType: Purchase Order,Customer Contact,客戶聯絡
-DocType: Patient Appointment,Check availability,檢查可用性
-DocType: Retention Bonus,Bonus Payment Date,獎金支付日期
-DocType: Employee,Job Applicant,求職者
-apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,這是基於對這種供應商的交易。詳情請參閱以下時間表
-DocType: Manufacturing Settings,Overproduction Percentage For Work Order,工作訂單的生產率過高百分比
-DocType: Delivery Note,Transport Receipt Date,運輸收貨日期
-DocType: Shopify Settings,Sales Order Series,銷售訂單系列
-apps/erpnext/erpnext/hr/utils.py +222,"More than one selection for {0} not \
+Period Name,期間名稱
+Salary Mode,薪酬模式
+Divorced,離婚
+Post Route Key,郵政路線密鑰
+Allow Item to be added multiple times in a transaction,允許項目在一個交易中被多次新增
+Cancel Material Visit {0} before cancelling this Warranty Claim,材質訪問{0}之前取消此保修索賠取消
+Assessment Reports,評估報告
+Consumer Products,消費類產品
+Notify Supplier,通知供應商
+Please select Party Type first,請選擇黨第一型
+Customer Items,客戶項目
+Costing and Billing,成本核算和計費
+Advance account currency should be same as company currency {0},預付科目貨幣應與公司貨幣{0}相同
+Token Endpoint,令牌端點
+Account {0}: Parent account {1} can not be a ledger,科目{0}：上層科目{1}不能是總帳
+Publish Item to hub.erpnext.com,發布項目hub.erpnext.com,
+Cannot find active Leave Period,找不到有效的休假期
+Evaluation,評估
+Default Unit of Measure,預設的計量單位
+All Sales Partner Contact,所有的銷售合作夥伴聯絡
+Leave Approvers,休假審批人
+Bio / Cover Letter,自傳/求職信
+Investigations,調查
+Click Enter To Add,點擊輸入要添加
+"Missing value for Password, API Key or Shopify URL",缺少密碼，API密鑰或Shopify網址的值
+All Accounts,所有科目
+Cannot transfer Employee with status Left,無法轉移狀態為左的員工
+"Stopped Production Order cannot be cancelled, Unstop it first to cancel",停止生產訂單無法取消，首先Unstop它取消
+Do you really want to scrap this asset?,難道你真的想放棄這項資產？
+Update Schedule,更新時間表
+Select Default Supplier,選擇默認供應商
+Show Employee,顯示員工
+New Exchange Rate,新匯率
+Currency is required for Price List {0},價格表{0}需填入貨幣種類
+* Will be calculated in the transaction.,*將被計算在該交易。
+Customer Contact,客戶聯絡
+Check availability,檢查可用性
+Bonus Payment Date,獎金支付日期
+Job Applicant,求職者
+This is based on transactions against this Supplier. See timeline below for details,這是基於對這種供應商的交易。詳情請參閱以下時間表
+Overproduction Percentage For Work Order,工作訂單的生產率過高百分比
+Transport Receipt Date,運輸收貨日期
+Sales Order Series,銷售訂單系列
+"More than one selection for {0} not \
 			allowed",對{0}的多個選擇不是\允許的
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +204,Actual type tax cannot be included in Item rate in row {0},實際類型稅不能被包含在商品率排{0}
-DocType: Allowed To Transact With,Allowed To Transact With,允許與
-DocType: Bank Guarantee,Customer,客戶
-DocType: Purchase Receipt Item,Required By,需求來自
-DocType: Delivery Note,Return Against Delivery Note,射向送貨單
-DocType: Asset Category,Finance Book Detail,財務帳簿細節
-DocType: Purchase Order,% Billed,％已開立帳單
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +41,Exchange Rate must be same as {0} {1} ({2}),匯率必須一致{0} {1}（{2}）
-DocType: Sales Invoice,Customer Name,客戶名稱
-DocType: Vehicle,Natural Gas,天然氣
-apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +63,Bank account cannot be named as {0},銀行科目不能命名為{0}
-DocType: Employee Tax Exemption Declaration,HRA as per Salary Structure,HRA根據薪資結構
-DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,頭（或組）針對其會計分錄是由和平衡得以維持。
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +197,Outstanding for {0} cannot be less than zero ({1}),傑出的{0}不能小於零（ {1} ）
-apps/erpnext/erpnext/public/js/controllers/transaction.js +882,Service Stop Date cannot be before Service Start Date,服務停止日期不能早於服務開始日期
-DocType: Manufacturing Settings,Default 10 mins,預設為10分鐘
-DocType: Leave Type,Leave Type Name,休假類型名稱
-apps/erpnext/erpnext/templates/pages/projects.js +66,Show open,公開顯示
-apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6,Checkout,查看
-DocType: Asset Finance Book,Depreciation Start Date,折舊開始日期
-DocType: Pricing Rule,Apply On,適用於
-DocType: Item Price,Multiple Item prices.,多個項目的價格。
-,Purchase Order Items To Be Received,未到貨的採購訂單項目
-DocType: SMS Center,All Supplier Contact,所有供應商聯絡
-DocType: Support Settings,Support Settings,支持設置
-apps/erpnext/erpnext/projects/doctype/project/project.py +84,Expected End Date can not be less than Expected Start Date,預計結束日期不能小於預期開始日期
-DocType: Amazon MWS Settings,Amazon MWS Settings,亞馬遜MWS設置
-apps/erpnext/erpnext/utilities/transaction_base.py +126,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,行＃{0}：速率必須與{1}：{2}（{3} / {4}）
-,Batch Item Expiry Status,批處理項到期狀態
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137,Bank Draft,銀行匯票
-DocType: Mode of Payment Account,Mode of Payment Account,支付帳戶模式
-apps/erpnext/erpnext/config/healthcare.py +8,Consultation,會診
-DocType: Accounts Settings,Show Payment Schedule in Print,在打印中顯示付款時間表
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +21,Sales and Returns,銷售和退貨
-apps/erpnext/erpnext/stock/doctype/item/item.js +58,Show Variants,顯示變體
-DocType: Academic Term,Academic Term,學期
-DocType: Employee Tax Exemption Sub Category,Employee Tax Exemption Sub Category,員工免稅子類別
-apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +61,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of benefit application pro-rata component\
+Actual type tax cannot be included in Item rate in row {0},實際類型稅不能被包含在商品率排{0}
+Allowed To Transact With,允許與
+Customer,客戶
+Required By,需求來自
+Return Against Delivery Note,射向送貨單
+Finance Book Detail,財務帳簿細節
+% Billed,％已開立帳單
+Exchange Rate must be same as {0} {1} ({2}),匯率必須一致{0} {1}（{2}）
+Customer Name,客戶名稱
+Natural Gas,天然氣
+Bank account cannot be named as {0},銀行科目不能命名為{0}
+HRA as per Salary Structure,HRA根據薪資結構
+Heads (or groups) against which Accounting Entries are made and balances are maintained.,頭（或組）針對其會計分錄是由和平衡得以維持。
+Outstanding for {0} cannot be less than zero ({1}),傑出的{0}不能小於零（ {1} ）
+Service Stop Date cannot be before Service Start Date,服務停止日期不能早於服務開始日期
+Default 10 mins,預設為10分鐘
+Leave Type Name,休假類型名稱
+Show open,公開顯示
+Checkout,查看
+Depreciation Start Date,折舊開始日期
+Apply On,適用於
+Multiple Item prices.,多個項目的價格。
+Purchase Order Items To Be Received,未到貨的採購訂單項目
+All Supplier Contact,所有供應商聯絡
+Support Settings,支持設置
+Expected End Date can not be less than Expected Start Date,預計結束日期不能小於預期開始日期
+Amazon MWS Settings,亞馬遜MWS設置
+Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,行＃{0}：速率必須與{1}：{2}（{3} / {4}）
+Batch Item Expiry Status,批處理項到期狀態
+Bank Draft,銀行匯票
+Mode of Payment Account,支付帳戶模式
+Consultation,會診
+Show Payment Schedule in Print,在打印中顯示付款時間表
+Sales and Returns,銷售和退貨
+Show Variants,顯示變體
+Academic Term,學期
+Employee Tax Exemption Sub Category,員工免稅子類別
+"Maximum benefit of employee {0} exceeds {1} by the sum {2} of benefit application pro-rata component\
 			amount and previous claimed amount",員工{0}的最高福利超過{1}，福利應用程序按比例分量\金額和上次索賠金額的總和{2}
-DocType: Opening Invoice Creation Tool Item,Quantity,數量
-,Customers Without Any Sales Transactions,沒有任何銷售交易的客戶
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +590,Accounts table cannot be blank.,賬表不能為空。
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +164,Loans (Liabilities),借款（負債）
-DocType: Patient Encounter,Encounter Time,遇到時間
-DocType: Staffing Plan Detail,Total Estimated Cost,預計總成本
-DocType: Employee Education,Year of Passing,路過的一年
-DocType: Routing,Routing Name,路由名稱
-DocType: Item,Country of Origin,出生國家
-DocType: Soil Texture,Soil Texture Criteria,土壤質地標準
-apps/erpnext/erpnext/templates/includes/product_page.js +34,In Stock,庫存
-apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16,Primary Contact Details,主要聯繫方式
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,開放式問題
-DocType: Production Plan Item,Production Plan Item,生產計劃項目
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +166,User {0} is already assigned to Employee {1},用戶{0}已經被分配給員工{1}
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31,Health Care,保健
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,Delay in payment (Days),延遲支付（天）
-DocType: Payment Terms Template Detail,Payment Terms Template Detail,付款條款模板細節
-DocType: Delivery Note,Issue Credit Note,發行信用票據
-DocType: Lab Prescription,Lab Prescription,實驗室處方
-,Delay Days,延遲天數
-apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26,Service Expense,服務費用
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1009,Serial Number: {0} is already referenced in Sales Invoice: {1},序號：{0}已在銷售發票中引用：{1}
-DocType: Bank Statement Transaction Invoice Item,Invoice,發票
-DocType: Purchase Invoice Item,Item Weight Details,項目重量細節
-DocType: Asset Maintenance Log,Periodicity,週期性
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,會計年度{0}是必需的
-DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,植株之間的最小距離，以獲得最佳生長
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21,Defense,防禦
-DocType: Salary Component,Abbr,縮寫
-DocType: Timesheet,Total Costing Amount,總成本計算金額
-DocType: Delivery Note,Vehicle No,車輛牌照號碼
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +177,Please select Price List,請選擇價格表
-DocType: Accounts Settings,Currency Exchange Settings,貨幣兌換設置
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +94,Row #{0}: Payment document is required to complete the trasaction,列＃{0}：付款單據才能完成trasaction
-DocType: Work Order Operation,Work In Progress,在製品
-apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13,Please select date,請選擇日期
-DocType: Item Price,Minimum Qty ,最低數量
-DocType: Finance Book,Finance Book,金融書
-DocType: Daily Work Summary Group,Holiday List,假日列表
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90,Accountant,會計人員
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +61,Selling Price List,賣價格表
-DocType: Patient,Tobacco Current Use,煙草當前使用
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +68,Selling Rate,賣出率
-DocType: Cost Center,Stock User,庫存用戶
-DocType: Soil Analysis,(Ca+Mg)/K,（鈣+鎂）/ K
-DocType: Delivery Stop,Contact Information,聯繫信息
-DocType: Company,Phone No,電話號碼
-DocType: Delivery Trip,Initial Email Notification Sent,初始電子郵件通知已發送
-DocType: Bank Statement Settings,Statement Header Mapping,聲明標題映射
-,Sales Partners Commission,銷售合作夥伴佣金
-DocType: Purchase Invoice,Rounding Adjustment,舍入調整
-apps/erpnext/erpnext/setup/doctype/company/company.py +50,Abbreviation cannot have more than 5 characters,縮寫不能有超過5個字符
-apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js +7,Payment Request,付錢請求
-apps/erpnext/erpnext/config/accounts.py +556,To view logs of Loyalty Points assigned to a Customer.,查看分配給客戶的忠誠度積分的日誌。
-DocType: Asset,Value After Depreciation,折舊後
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8,Related,有關
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +46,Attendance date can not be less than employee's joining date,考勤日期不得少於員工的加盟日期
-DocType: Grading Scale,Grading Scale Name,分級標準名稱
-apps/erpnext/erpnext/public/js/hub/marketplace.js +147,Add Users to Marketplace,將用戶添加到市場
-apps/erpnext/erpnext/accounts/doctype/account/account.js +37,This is a root account and cannot be edited.,這是一個 root 科目，不能被編輯。
-DocType: BOM,Operations,操作
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38,Cannot set authorization on basis of Discount for {0},不能在折扣的基礎上設置授權{0}
-DocType: Subscription,Subscription Start Date,訂閱開始日期
-DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Appointment charges.,如果未在患者中設置預約費用，則使用默認應收科目。
-DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name",附加.csv文件有兩列，一為舊名稱，一個用於新名稱
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +195,From Address 2,來自地址2
-apps/erpnext/erpnext/accounts/utils.py +74,{0} {1} not in any active Fiscal Year.,{0} {1} 不在任何有效的會計年度
-DocType: Packed Item,Parent Detail docname,家長可採用DocName細節
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: {0}, Item Code: {1} and Customer: {2}",參考：{0}，商品編號：{1}和顧客：{2}
-apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py +377,{0} {1} is not present in the parent company,在母公司中不存在{0} {1}
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +215,Trial Period End Date Cannot be before Trial Period Start Date,試用期結束日期不能在試用期開始日期之前
-apps/erpnext/erpnext/utilities/user_progress.py +146,Kg,公斤
-DocType: Tax Withholding Category,Tax Withholding Category,預扣稅類別
-apps/erpnext/erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py +23,Cancel the journal entry {0} first,首先取消日記條目{0}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +113,BOM is not specified for subcontracting item {0} at row {1},沒有為行{1}的轉包商品{0}指定BOM
-apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149,{0} Result submittted,{0}結果提交
-apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74,Timespan,時間跨度
-apps/erpnext/erpnext/templates/pages/search_help.py +13,Help Results for,幫助結果
-apps/erpnext/erpnext/public/js/stock_analytics.js +58,Select Warehouse...,選擇倉庫...
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6,Advertising,廣告
-apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,同一家公司進入不止一次
-apps/erpnext/erpnext/accounts/party.py +42,Not permitted for {0},不允許{0}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +624,Get items from,取得項目來源
-DocType: Price List,Price Not UOM Dependant,價格不依賴於UOM
-DocType: Purchase Invoice,Apply Tax Withholding Amount,申請預扣稅金額
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +539,Stock cannot be updated against Delivery Note {0},送貨單{0}不能更新庫存
-apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py +124,Total Amount Credited,總金額
-apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},產品{0}
-apps/erpnext/erpnext/templates/generators/item_group.html +33,No items listed,沒有列出項目
-DocType: Asset Repair,Error Description,錯誤說明
-DocType: Payment Reconciliation,Reconcile,調和
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30,Grocery,雜貨
-DocType: Quality Inspection Reading,Reading 1,閱讀1
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40,Pension Funds,養老基金
-DocType: Exchange Rate Revaluation Account,Gain/Loss,收益/損失
-DocType: Accounts Settings,Use Custom Cash Flow Format,使用自定義現金流量格式
-DocType: SMS Center,All Sales Person,所有的銷售人員
-DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,**月度分配**幫助你分配預算/目標跨越幾個月，如果你在你的業務有季節性。
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1768,Not items found,未找到項目
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +267,Salary Structure Missing,薪酬結構缺失
-DocType: Lead,Person Name,人姓名
-DocType: Sales Invoice Item,Sales Invoice Item,銷售發票項目
-DocType: Account,Credit,信用
-DocType: POS Profile,Write Off Cost Center,沖銷成本中心
-apps/erpnext/erpnext/public/js/setup_wizard.js +117,"e.g. ""Primary School"" or ""University""",如“小學”或“大學”
-apps/erpnext/erpnext/config/stock.py +28,Stock Reports,庫存報告
-DocType: Warehouse,Warehouse Detail,倉庫的詳細資訊
-apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,該期限結束日期不能晚於學年年終日期到這個詞聯繫在一起（學年{}）。請更正日期，然後再試一次。
-apps/erpnext/erpnext/stock/doctype/item/item.py +298,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item",“是固定的資產”不能選中，作為資產記錄存在對項目
-DocType: Delivery Trip,Departure Time,出發時間
-DocType: Vehicle Service,Brake Oil,剎車油
-DocType: Tax Rule,Tax Type,稅收類型
-,Completed Work Orders,完成的工作訂單
-DocType: Support Settings,Forum Posts,論壇帖子
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +603,Taxable Amount,應稅金額
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +161,You are not authorized to add or update entries before {0},你無權添加或更新{0}之前的條目
-DocType: Leave Policy,Leave Policy Details,退出政策詳情
-DocType: BOM,Item Image (if not slideshow),產品圖片（如果不是幻燈片）
-DocType: Work Order Operation,(Hour Rate / 60) * Actual Operation Time,（工時率/ 60）*實際操作時間
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1136,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,行＃{0}：參考文檔類型必須是費用索賠或日記帳分錄之一
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1053,Select BOM,選擇BOM
-DocType: SMS Log,SMS Log,短信日誌
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,交付項目成本
-apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +39,The holiday on {0} is not between From Date and To Date,在{0}這個節日之間沒有從日期和結束日期
-DocType: Inpatient Record,Admission Scheduled,入學時間表
-DocType: Student Log,Student Log,學生登錄
-apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,供應商榜單。
-DocType: Lead,Interested,有興趣
-apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Opening,開盤
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +36,From {0} to {1},從{0} {1}
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +51,Failed to setup taxes,無法設置稅收
-DocType: Item,Copy From Item Group,從項目群組複製
-DocType: Journal Entry,Opening Entry,開放報名
-apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,科目只需支付
-DocType: Loan,Repay Over Number of Periods,償還期的超過數
-DocType: Stock Entry,Additional Costs,額外費用
-apps/erpnext/erpnext/accounts/doctype/account/account.py +145,Account with existing transaction can not be converted to group.,科目與現有的交易不能被轉換到群組。
-DocType: Lead,Product Enquiry,產品查詢
-DocType: Education Settings,Validate Batch for Students in Student Group,驗證學生組學生的批次
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +38,No leave record found for employee {0} for {1},未找到員工的假期記錄{0} {1}
-DocType: Company,Unrealized Exchange Gain/Loss Account,未實現的匯兌收益/損失科目
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23,Please enter company first,請先輸入公司
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +626,Please select Company first,請首先選擇公司
-DocType: Employee Education,Under Graduate,根據研究生
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +290,Please set default template for Leave Status Notification in HR Settings.,請在人力資源設置中設置離職狀態通知的默認模板。
-apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,目標在
-DocType: BOM,Total Cost,總成本
-DocType: Soil Analysis,Ca/K,鈣/ K
-DocType: Salary Slip,Employee Loan,員工貸款
-DocType: Fee Schedule,Send Payment Request Email,發送付款請求電子郵件
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +282,Item {0} does not exist in the system or has expired,項目{0}不存在於系統中或已過期
-DocType: Supplier,Leave blank if the Supplier is blocked indefinitely,如果供應商被無限期封鎖，請留空
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44,Real Estate,房地產
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,科目狀態
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41,Pharmaceuticals,製藥
-DocType: Purchase Invoice Item,Is Fixed Asset,是固定的資產
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +355,"Available qty is {0}, you need {1}",可用數量是{0}，則需要{1}
-DocType: Expense Claim Detail,Claim Amount,索賠金額
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +646,Work Order has been {0},工單已{0}
-DocType: Budget,Applicable on Purchase Order,適用於採購訂單
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56,Duplicate customer group found in the cutomer group table,在CUTOMER組表中找到重複的客戶群
-DocType: Location,Location Name,地點名稱
-apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html +7,Event Location,活動地點
-DocType: Asset Settings,Asset Settings,資產設置
-DocType: Assessment Result,Grade,年級
-DocType: Restaurant Table,No of Seats,座位數
-DocType: Sales Invoice Item,Delivered By Supplier,交付供應商
-DocType: Asset Maintenance Task,Asset Maintenance Task,資產維護任務
-DocType: SMS Center,All Contact,所有聯絡
-DocType: Daily Work Summary,Daily Work Summary,每日工作總結
-DocType: Period Closing Voucher,Closing Fiscal Year,截止會計年度
-apps/erpnext/erpnext/accounts/party.py +425,{0} {1} is frozen,{0} {1}被凍結
-apps/erpnext/erpnext/setup/doctype/company/company.py +152,Please select Existing Company for creating Chart of Accounts,請選擇現有的公司創建會計科目表
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +84,Stock Expenses,庫存費用
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +111,Select Target Warehouse,選擇目標倉庫
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +111,Select Target Warehouse,選擇目標倉庫
-apps/erpnext/erpnext/hr/doctype/employee/employee.js +87,Please enter Preferred Contact Email,請輸入首選電子郵件聯繫
-DocType: Journal Entry,Contra Entry,魂斗羅進入
-DocType: Journal Entry Account,Credit in Company Currency,信用在公司貨幣
-DocType: Lab Test UOM,Lab Test UOM,實驗室測試UOM
-DocType: Delivery Note,Installation Status,安裝狀態
-DocType: BOM,Quality Inspection Template,質量檢驗模板
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +136,"Do you want to update attendance?<br>Present: {0}\
+Quantity,數量
+Customers Without Any Sales Transactions,沒有任何銷售交易的客戶
+Accounts table cannot be blank.,賬表不能為空。
+Loans (Liabilities),借款（負債）
+Encounter Time,遇到時間
+Total Estimated Cost,預計總成本
+Year of Passing,路過的一年
+Routing Name,路由名稱
+Country of Origin,出生國家
+Soil Texture Criteria,土壤質地標準
+In Stock,庫存
+Primary Contact Details,主要聯繫方式
+Open Issues,開放式問題
+Production Plan Item,生產計劃項目
+User {0} is already assigned to Employee {1},用戶{0}已經被分配給員工{1}
+Health Care,保健
+Delay in payment (Days),延遲支付（天）
+Payment Terms Template Detail,付款條款模板細節
+Issue Credit Note,發行信用票據
+Lab Prescription,實驗室處方
+Delay Days,延遲天數
+Service Expense,服務費用
+Serial Number: {0} is already referenced in Sales Invoice: {1},序號：{0}已在銷售發票中引用：{1}
+Invoice,發票
+Item Weight Details,項目重量細節
+Periodicity,週期性
+Fiscal Year {0} is required,會計年度{0}是必需的
+The minimum distance between rows of plants for optimum growth,植株之間的最小距離，以獲得最佳生長
+Defense,防禦
+Abbr,縮寫
+Total Costing Amount,總成本計算金額
+Vehicle No,車輛牌照號碼
+Please select Price List,請選擇價格表
+Currency Exchange Settings,貨幣兌換設置
+Row #{0}: Payment document is required to complete the trasaction,列＃{0}：付款單據才能完成trasaction,
+Work In Progress,在製品
+Please select date,請選擇日期
+Minimum Qty ,最低數量
+Finance Book,金融書
+Holiday List,假日列表
+Accountant,會計人員
+Selling Price List,賣價格表
+Tobacco Current Use,煙草當前使用
+Selling Rate,賣出率
+Stock User,庫存用戶
+(Ca+Mg)/K,（鈣+鎂）/ K,
+Contact Information,聯繫信息
+Phone No,電話號碼
+Initial Email Notification Sent,初始電子郵件通知已發送
+Statement Header Mapping,聲明標題映射
+Sales Partners Commission,銷售合作夥伴佣金
+Rounding Adjustment,舍入調整
+Abbreviation cannot have more than 5 characters,縮寫不能有超過5個字符
+Payment Request,付錢請求
+To view logs of Loyalty Points assigned to a Customer.,查看分配給客戶的忠誠度積分的日誌。
+Value After Depreciation,折舊後
+Related,有關
+Attendance date can not be less than employee's joining date,考勤日期不得少於員工的加盟日期
+Grading Scale Name,分級標準名稱
+Add Users to Marketplace,將用戶添加到市場
+This is a root account and cannot be edited.,這是一個 root 科目，不能被編輯。
+Operations,操作
+Cannot set authorization on basis of Discount for {0},不能在折扣的基礎上設置授權{0}
+Subscription Start Date,訂閱開始日期
+Default receivable accounts to be used if not set in Patient to book Appointment charges.,如果未在患者中設置預約費用，則使用默認應收科目。
+"Attach .csv file with two columns, one for the old name and one for the new name",附加.csv文件有兩列，一為舊名稱，一個用於新名稱
+From Address 2,來自地址2,
+{0} {1} not in any active Fiscal Year.,{0} {1} 不在任何有效的會計年度
+Parent Detail docname,家長可採用DocName細節
+"Reference: {0}, Item Code: {1} and Customer: {2}",參考：{0}，商品編號：{1}和顧客：{2}
+{0} {1} is not present in the parent company,在母公司中不存在{0} {1}
+Trial Period End Date Cannot be before Trial Period Start Date,試用期結束日期不能在試用期開始日期之前
+Kg,公斤
+Tax Withholding Category,預扣稅類別
+Cancel the journal entry {0} first,首先取消日記條目{0}
+BOM is not specified for subcontracting item {0} at row {1},沒有為行{1}的轉包商品{0}指定BOM,
+{0} Result submittted,{0}結果提交
+Timespan,時間跨度
+Help Results for,幫助結果
+Select Warehouse...,選擇倉庫...
+Advertising,廣告
+Same Company is entered more than once,同一家公司進入不止一次
+Not permitted for {0},不允許{0}
+Get items from,取得項目來源
+Price Not UOM Dependant,價格不依賴於UOM,
+Apply Tax Withholding Amount,申請預扣稅金額
+Stock cannot be updated against Delivery Note {0},送貨單{0}不能更新庫存
+Total Amount Credited,總金額
+Product {0},產品{0}
+No items listed,沒有列出項目
+Error Description,錯誤說明
+Reconcile,調和
+Grocery,雜貨
+Reading 1,閱讀1,
+Pension Funds,養老基金
+Gain/Loss,收益/損失
+Use Custom Cash Flow Format,使用自定義現金流量格式
+All Sales Person,所有的銷售人員
+**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,**月度分配**幫助你分配預算/目標跨越幾個月，如果你在你的業務有季節性。
+Not items found,未找到項目
+Salary Structure Missing,薪酬結構缺失
+Person Name,人姓名
+Sales Invoice Item,銷售發票項目
+Credit,信用
+Write Off Cost Center,沖銷成本中心
+"e.g. ""Primary School"" or ""University""",如“小學”或“大學”
+Stock Reports,庫存報告
+Warehouse Detail,倉庫的詳細資訊
+The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,該期限結束日期不能晚於學年年終日期到這個詞聯繫在一起（學年{}）。請更正日期，然後再試一次。
+"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item",“是固定的資產”不能選中，作為資產記錄存在對項目
+Departure Time,出發時間
+Brake Oil,剎車油
+Tax Type,稅收類型
+Completed Work Orders,完成的工作訂單
+Forum Posts,論壇帖子
+Taxable Amount,應稅金額
+You are not authorized to add or update entries before {0},你無權添加或更新{0}之前的條目
+Leave Policy Details,退出政策詳情
+Item Image (if not slideshow),產品圖片（如果不是幻燈片）
+(Hour Rate / 60) * Actual Operation Time,（工時率/ 60）*實際操作時間
+Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,行＃{0}：參考文檔類型必須是費用索賠或日記帳分錄之一
+Select BOM,選擇BOM,
+SMS Log,短信日誌
+Cost of Delivered Items,交付項目成本
+The holiday on {0} is not between From Date and To Date,在{0}這個節日之間沒有從日期和結束日期
+Admission Scheduled,入學時間表
+Student Log,學生登錄
+Templates of supplier standings.,供應商榜單。
+Interested,有興趣
+Opening,開盤
+From {0} to {1},從{0} {1}
+Failed to setup taxes,無法設置稅收
+Copy From Item Group,從項目群組複製
+Opening Entry,開放報名
+Account Pay Only,科目只需支付
+Repay Over Number of Periods,償還期的超過數
+Additional Costs,額外費用
+Account with existing transaction can not be converted to group.,科目與現有的交易不能被轉換到群組。
+Product Enquiry,產品查詢
+Validate Batch for Students in Student Group,驗證學生組學生的批次
+No leave record found for employee {0} for {1},未找到員工的假期記錄{0} {1}
+Unrealized Exchange Gain/Loss Account,未實現的匯兌收益/損失科目
+Please enter company first,請先輸入公司
+Please select Company first,請首先選擇公司
+Under Graduate,根據研究生
+Please set default template for Leave Status Notification in HR Settings.,請在人力資源設置中設置離職狀態通知的默認模板。
+Target On,目標在
+Total Cost,總成本
+Ca/K,鈣/ K,
+Employee Loan,員工貸款
+Send Payment Request Email,發送付款請求電子郵件
+Item {0} does not exist in the system or has expired,項目{0}不存在於系統中或已過期
+Leave blank if the Supplier is blocked indefinitely,如果供應商被無限期封鎖，請留空
+Real Estate,房地產
+Statement of Account,科目狀態
+Pharmaceuticals,製藥
+Is Fixed Asset,是固定的資產
+"Available qty is {0}, you need {1}",可用數量是{0}，則需要{1}
+Claim Amount,索賠金額
+Work Order has been {0},工單已{0}
+Applicable on Purchase Order,適用於採購訂單
+Duplicate customer group found in the cutomer group table,在CUTOMER組表中找到重複的客戶群
+Location Name,地點名稱
+Event Location,活動地點
+Asset Settings,資產設置
+Grade,年級
+No of Seats,座位數
+Delivered By Supplier,交付供應商
+Asset Maintenance Task,資產維護任務
+All Contact,所有聯絡
+Daily Work Summary,每日工作總結
+Closing Fiscal Year,截止會計年度
+{0} {1} is frozen,{0} {1}被凍結
+Please select Existing Company for creating Chart of Accounts,請選擇現有的公司創建會計科目表
+Stock Expenses,庫存費用
+Select Target Warehouse,選擇目標倉庫
+Select Target Warehouse,選擇目標倉庫
+Please enter Preferred Contact Email,請輸入首選電子郵件聯繫
+Contra Entry,魂斗羅進入
+Credit in Company Currency,信用在公司貨幣
+Lab Test UOM,實驗室測試UOM,
+Installation Status,安裝狀態
+Quality Inspection Template,質量檢驗模板
+"Do you want to update attendance?<br>Present: {0}\
 					<br>Absent: {1}",你想更新考勤？ <br>現任：{0} \ <br>缺席：{1}
-apps/erpnext/erpnext/controllers/buying_controller.py +433,Accepted + Rejected Qty must be equal to Received quantity for Item {0},品項{0}的允收＋批退的數量必須等於收到量
-DocType: Item,Supply Raw Materials for Purchase,供應原料採購
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +441,"Cannot ensure delivery by Serial No as \
+Accepted + Rejected Qty must be equal to Received quantity for Item {0},品項{0}的允收＋批退的數量必須等於收到量
+Supply Raw Materials for Purchase,供應原料採購
+"Cannot ensure delivery by Serial No as \
 				Item {0} is added with and without Ensure Delivery by \
 				Serial No.",無法通過序列號確保交貨，因為\項目{0}是否添加了確保交貨\序列號
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +203,At least one mode of payment is required for POS invoice.,付款中的至少一個模式需要POS發票。
-DocType: Bank Statement Transaction Invoice Item,Bank Statement Transaction Invoice Item,銀行對賬單交易發票項目
-DocType: Products Settings,Show Products as a List,產品展示作為一個列表
-DocType: Salary Detail,Tax on flexible benefit,對靈活福利徵稅
-apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.py +43,Item {0} is not active or end of life has been reached,項目{0}不活躍或生命的盡頭已經達到
-DocType: Student Admission Program,Minimum Age,最低年齡
-apps/erpnext/erpnext/utilities/user_progress.py +190,Example: Basic Mathematics,例如：基礎數學
-apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py +39,Diff Qty,差異數量
-DocType: Production Plan,Material Request Detail,材料請求詳情
-DocType: Selling Settings,Default Quotation Validity Days,默認報價有效天數
-apps/erpnext/erpnext/controllers/accounts_controller.py +886,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included",要包括稅款，行{0}項率，稅收行{1}也必須包括在內
-DocType: Payroll Entry,Validate Attendance,驗證出席
-DocType: Sales Invoice,Change Amount,變動金額
-DocType: Party Tax Withholding Config,Certificate Received,已收到證書
-DocType: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,設置B2C的發票值。 B2CL和B2CS根據此發票值計算。
-DocType: BOM Update Tool,New BOM,新的物料清單
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +307,Prescribed Procedures,規定程序
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,Show only POS,只顯示POS
-DocType: Supplier Group,Supplier Group Name,供應商集團名稱
-DocType: Driver,Driving License Categories,駕駛執照類別
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +124,Please enter Delivery Date,請輸入交貨日期
-DocType: Depreciation Schedule,Make Depreciation Entry,計提折舊進入
-DocType: Closed Document,Closed Document,關閉文件
-DocType: HR Settings,Leave Settings,保留設置
-apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.js +76,Number of positions cannot be less then current count of employees,職位數量不能少於當前員工人數
-DocType: Lead,Request Type,請求類型
-DocType: Purpose of Travel,Purpose of Travel,旅行目的
-DocType: Payroll Period,Payroll Periods,工資期間
-apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +18,Make Employee,使員工
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,廣播
-apps/erpnext/erpnext/config/accounts.py +538,Setup mode of POS (Online / Offline),POS（在線/離線）的設置模式
-DocType: Manufacturing Settings,Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order,禁止根據工作訂單創建時間日誌。不得根據工作指令跟踪操作
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +144,Execution,執行
-apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,進行的作業細節。
-DocType: Asset Maintenance Log,Maintenance Status,維修狀態
-apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10,Membership Details,會員資格
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}：需要對供應商應付帳款{2}
-apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,項目和定價
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},總時間：{0}
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,From Date should be within the Fiscal Year. Assuming From Date = {0},從日期應該是在財政年度內。假設起始日期＝{0}
-DocType: Drug Prescription,Interval,間隔
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +211,Preference,偏愛
-DocType: Supplier,Individual,個人
-DocType: Academic Term,Academics User,學術界用戶
-DocType: Cheque Print Template,Amount In Figure,量圖
-DocType: Loan Application,Loan Info,貸款信息
-apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,規劃維護訪問。
-DocType: Supplier Scorecard Period,Supplier Scorecard Period,供應商記分卡期
-DocType: Share Transfer,Share Transfer,股份轉讓
-,Expiring Memberships,即將到期的會員
-DocType: POS Profile,Customer Groups,客戶群
-apps/erpnext/erpnext/public/js/financial_statements.js +53,Financial Statements,財務報表
-DocType: Guardian,Students,學生們
-apps/erpnext/erpnext/config/selling.py +91,Rules for applying pricing and discount.,規則適用的定價和折扣。
-DocType: Daily Work Summary,Daily Work Summary Group,日常工作總結小組
-DocType: Practitioner Schedule,Time Slots,時隙
-apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,價格表必須適用於購買或出售
-DocType: Shift Assignment,Shift Request,移位請求
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79,Installation date cannot be before delivery date for Item {0},品項{0}的安裝日期不能早於交貨日期
-DocType: Pricing Rule,Discount on Price List Rate (%),折扣價目表率（％）
-apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112,Item Template,項目模板
-DocType: Job Offer,Select Terms and Conditions,選擇條款和條件
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +87,Out Value,輸出值
-DocType: Bank Statement Settings Item,Bank Statement Settings Item,銀行對賬單設置項目
-DocType: Woocommerce Settings,Woocommerce Settings,Woocommerce設置
-DocType: Production Plan,Sales Orders,銷售訂單
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +203,Multiple Loyalty Program found for the Customer. Please select manually.,為客戶找到多個忠誠度計劃。請手動選擇。
-DocType: Purchase Taxes and Charges,Valuation,計價
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +436,Set as Default,設為預設
-,Purchase Order Trends,採購訂單趨勢
-apps/erpnext/erpnext/utilities/user_progress.py +78,Go to Customers,轉到客戶
-DocType: Hotel Room Reservation,Late Checkin,延遲入住
-apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,The request for quotation can be accessed by clicking on the following link,報價請求可以通過點擊以下鏈接進行訪問
-DocType: SG Creation Tool Course,SG Creation Tool Course,SG創建工具課程
-DocType: Bank Statement Transaction Invoice Item,Payment Description,付款說明
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +357,Insufficient Stock,庫存不足
-DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,禁用產能規劃和時間跟踪
-DocType: Email Digest,New Sales Orders,新的銷售訂單
-DocType: Bank Account,Bank Account,銀行帳戶
-DocType: Travel Itinerary,Check-out Date,離開日期
-DocType: Leave Type,Allow Negative Balance,允許負平衡
-apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',您不能刪除項目類型“外部”
-apps/erpnext/erpnext/public/js/utils.js +274,Select Alternate Item,選擇備用項目
-DocType: Employee,Create User,創建用戶
-DocType: Selling Settings,Default Territory,預設地域
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53,Television,電視
-DocType: Work Order Operation,Updated via 'Time Log',經由“時間日誌”更新
-apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py +13,Select the customer or supplier.,選擇客戶或供應商。
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +449,Advance amount cannot be greater than {0} {1},提前量不能大於{0} {1}
-apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +55,"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}",時隙滑動，時隙{0}到{1}與現有時隙{2}重疊到{3}
-DocType: Naming Series,Series List for this Transaction,本交易系列表
-DocType: Company,Enable Perpetual Inventory,啟用永久庫存
-DocType: Bank Guarantee,Charges Incurred,收費發生
-DocType: Company,Default Payroll Payable Account,默認情況下，應付職工薪酬帳戶
-apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51,Update Email Group,更新電子郵件組
-DocType: Sales Invoice,Is Opening Entry,是開放登錄
-DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ",如果取消選中，該項目不會出現在銷售發票中，但可用於創建組測試。
-DocType: Customer Group,Mention if non-standard receivable account applicable,何況，如果不規範應收帳款適用
-DocType: Course Schedule,Instructor Name,導師姓名
-DocType: Company,Arrear Component,欠費組件
-DocType: Supplier Scorecard,Criteria Setup,條件設置
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +199,For Warehouse is required before Submit,對於倉庫之前，需要提交
-DocType: Codification Table,Medical Code,醫療代號
-apps/erpnext/erpnext/config/integrations.py +37,Connect Amazon with ERPNext,將Amazon與ERPNext連接起來
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20,Please enter Company,請輸入公司名稱
-DocType: Delivery Note Item,Against Sales Invoice Item,對銷售發票項目
-DocType: Agriculture Analysis Criteria,Linked Doctype,鏈接的文檔類型
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +98,Net Cash from Financing,從融資淨現金
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2389,"LocalStorage is full , did not save",localStorage的滿了，沒救
-DocType: Lead,Address & Contact,地址及聯絡方式
-DocType: Leave Allocation,Add unused leaves from previous allocations,從以前的分配添加未使用的休假
-DocType: Sales Partner,Partner website,合作夥伴網站
-DocType: Restaurant Order Entry,Add Item,新增項目
-DocType: Party Tax Withholding Config,Party Tax Withholding Config,黨的預扣稅配置
-DocType: Lab Test,Custom Result,自定義結果
-DocType: Delivery Stop,Contact Name,聯絡人姓名
-DocType: Course Assessment Criteria,Course Assessment Criteria,課程評價標準
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +21,Tax Id: ,稅號：
-apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +216,Student ID: ,學生卡：
-DocType: POS Customer Group,POS Customer Group,POS客戶群
-DocType: Healthcare Practitioner,Practitioner Schedules,從業者時間表
-DocType: Vehicle,Additional Details,額外細節
-apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,請求您的報價。
-DocType: POS Closing Voucher Details,Collected Amount,收集金額
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,這是基於對這個項目產生的考勤表
-,Open Work Orders,打開工作訂單
-DocType: Healthcare Practitioner,Out Patient Consulting Charge Item,出患者諮詢費用項目
-DocType: Payment Term,Credit Months,信貸月份
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +494,Net Pay cannot be less than 0,淨工資不能低於0
-DocType: Contract,Fulfilled,達到
-DocType: Inpatient Record,Discharge Scheduled,出院預定
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +138,Relieving Date must be greater than Date of Joining,解除日期必須大於加入的日期
-DocType: POS Closing Voucher,Cashier,出納員
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +198,Leaves per Year,每年葉
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +162,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,行{0}：請檢查'是進階'對科目{1}，如果這是一個進階條目。
-apps/erpnext/erpnext/stock/utils.py +243,Warehouse {0} does not belong to company {1},倉庫{0}不屬於公司{1}
-DocType: Email Digest,Profit & Loss,收益與損失
-DocType: Task,Total Costing Amount (via Time Sheet),總成本計算量（通過時間表）
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +76,Please setup Students under Student Groups,請設置學生組的學生
-DocType: Item Website Specification,Item Website Specification,項目網站規格
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +543,Leave Blocked,禁假的
-apps/erpnext/erpnext/stock/doctype/item/item.py +818,Item {0} has reached its end of life on {1},項{0}已達到其壽命結束於{1}
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +82,Bank Entries,銀行條目
-DocType: Customer,Is Internal Customer,是內部客戶
-apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +27,"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)",如果選中自動選擇，則客戶將自動與相關的忠誠度計劃鏈接（保存時）
-DocType: Stock Reconciliation Item,Stock Reconciliation Item,庫存調整項目
-DocType: Stock Entry,Sales Invoice No,銷售發票號碼
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +145,Supply Type,供應類型
-DocType: Material Request Item,Min Order Qty,最小訂貨量
-DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,學生組創建工具課程
-DocType: Lead,Do Not Contact,不要聯絡
-apps/erpnext/erpnext/utilities/user_progress.py +210,People who teach at your organisation,誰在您的組織教人
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98,Software Developer,軟件開發人員
-DocType: Item,Minimum Order Qty,最低起訂量
-DocType: Supplier,Supplier Type,供應商類型
-DocType: Course Scheduling Tool,Course Start Date,課程開始日期
-,Student Batch-Wise Attendance,學生分批出席
-DocType: POS Profile,Allow user to edit Rate,允許用戶編輯率
-DocType: Item,Publish in Hub,在發布中心
-DocType: Student Admission,Student Admission,學生入學
-,Terretory,Terretory
-apps/erpnext/erpnext/stock/doctype/item/item.py +840,Item {0} is cancelled,項{0}將被取消
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +215,Depreciation Row {0}: Depreciation Start Date is entered as past date,折舊行{0}：折舊開始日期作為過去的日期輸入
-DocType: Contract Template,Fulfilment Terms and Conditions,履行條款和條件
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1138,Material Request,物料需求
-DocType: Bank Reconciliation,Update Clearance Date,更新日期間隙
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +494,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},項目{0}未發現“原材料提供&#39;表中的採購訂單{1}
-DocType: Salary Slip,Total Principal Amount,本金總額
-DocType: Student Guardian,Relation,關係
-DocType: Student Guardian,Mother,母親
-DocType: Restaurant Reservation,Reservation End Time,預訂結束時間
-DocType: Crop,Biennial,雙年展
-,BOM Variance Report,BOM差異報告
-apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,確認客戶的訂單。
-DocType: Purchase Receipt Item,Rejected Quantity,拒絕數量
-apps/erpnext/erpnext/education/doctype/fees/fees.py +80,Payment request {0} created,已創建付款請求{0}
-DocType: Inpatient Record,Admitted Datetime,承認日期時間
-DocType: Work Order,Backflush raw materials from work-in-progress warehouse,從在製品庫中反沖原料
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +79,Open Orders,開放訂單
-apps/erpnext/erpnext/healthcare/setup.py +187,Low Sensitivity,低靈敏度
-apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_log/shopify_log.js +16,Order rescheduled for sync,訂單重新安排同步
-apps/erpnext/erpnext/templates/emails/training_event.html +17,Please confirm once you have completed your training,完成培訓後請確認
-DocType: Lead,Suggestions,建議
-DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,在此地域設定跨群組項目間的預算。您還可以通過設定分配來包含季節性。
-DocType: Payment Term,Payment Term Name,付款條款名稱
-DocType: Healthcare Settings,Create documents for sample collection,創建樣本收集文件
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +308,Payment against {0} {1} cannot be greater than Outstanding Amount {2},對支付{0} {1}不能大於未償還{2}
-apps/erpnext/erpnext/patches/v11_0/add_healthcare_service_unit_tree_root.py +16,All Healthcare Service Units,所有醫療服務單位
-DocType: Lead,Mobile No.,手機號碼
-DocType: Maintenance Schedule,Generate Schedule,生成時間表
-DocType: Purchase Invoice Item,Expense Head,總支出
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +149,Please select Charge Type first,請先選擇付款類別
-DocType: Crop,"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ",你可以在這裡定義所有需要進行的作業。日場是用來提及任務需要執行的日子，1日是第一天等。
-DocType: Student Group Student,Student Group Student,學生組學生
-DocType: Education Settings,Education Settings,教育設置
-DocType: Vehicle Service,Inspection,檢查
-DocType: Exchange Rate Revaluation Account,Balance In Base Currency,平衡基礎貨幣
-DocType: Supplier Scorecard Scoring Standing,Max Grade,最高等級
-DocType: Email Digest,New Quotations,新報價
-apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py +60,Attendance not submitted for {0} as {1} on leave.,在{0}上沒有針對{1}上的考勤出席。
-DocType: Journal Entry,Payment Order,付款單
-DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,電子郵件工資單員工根據員工選擇首選的電子郵件
-DocType: Tax Rule,Shipping County,航運縣
-apps/erpnext/erpnext/config/desktop.py +159,Learn,學習
-DocType: Purchase Invoice Item,Enable Deferred Expense,啟用延期費用
-DocType: Asset,Next Depreciation Date,接下來折舊日期
-apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,每個員工活動費用
-DocType: Accounts Settings,Settings for Accounts,會計設定
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +800,Supplier Invoice No exists in Purchase Invoice {0},供應商發票不存在採購發票{0}
-apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,管理銷售人員樹。
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +105,"Cannot process route, since Google Maps Settings is disabled.",由於禁用了Google地圖設置，因此無法處理路線。
-DocType: Job Applicant,Cover Letter,求職信
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,傑出的支票及存款清除
-DocType: Item,Synced With Hub,同步轂
-DocType: Driver,Fleet Manager,車隊經理
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +573,Row #{0}: {1} can not be negative for item {2},行＃{0}：{1}不能為負值對項{2}
-apps/erpnext/erpnext/setup/doctype/company/company.js +129,Wrong Password,密碼錯誤
-DocType: Item,Variant Of,變種
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +387,Completed Qty can not be greater than 'Qty to Manufacture',完成數量不能大於“數量來製造”
-DocType: Period Closing Voucher,Closing Account Head,關閉帳戶頭
-DocType: Employee,External Work History,外部工作經歷
-apps/erpnext/erpnext/projects/doctype/task/task.py +114,Circular Reference Error,循環引用錯誤
-apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +206,Student Report Card,學生報告卡
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +207,From Pin Code,來自Pin Code
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Guardian1名稱
-DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,送貨單一被儲存，(Export)就會顯示出來。
-DocType: Cheque Print Template,Distance from left edge,從左側邊緣的距離
-apps/erpnext/erpnext/utilities/bot.py +29,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} [{1}]的單位（＃窗體/項目/ {1}）在[{2}]研究發現（＃窗體/倉儲/ {2}）
-DocType: Lead,Industry,行業
-DocType: BOM Item,Rate & Amount,價格和金額
-DocType: BOM,Transfer Material Against Job Card,轉移材料反對工作卡
-DocType: Stock Settings,Notify by Email on creation of automatic Material Request,在建立自動材料需求時以電子郵件通知
-apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77,Please set Hotel Room Rate on {},請在{}上設置酒店房價
-DocType: Journal Entry,Multi Currency,多幣種
-DocType: Bank Statement Transaction Invoice Item,Invoice Type,發票類型
-DocType: Employee Benefit Claim,Expense Proof,費用證明
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +990,Delivery Note,送貨單
-apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,建立稅
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +149,Cost of Sold Asset,出售資產的成本
-apps/erpnext/erpnext/accounts/utils.py +374,Payment Entry has been modified after you pulled it. Please pull it again.,付款項被修改，你把它之後。請重新拉。
-DocType: Program Enrollment Tool,New Student Batch,新學生批次
-apps/erpnext/erpnext/stock/doctype/item/item.py +510,{0} entered twice in Item Tax,{0}輸入兩次項目稅
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +121,Summary for this week and pending activities,本週和待活動總結
-DocType: Student Applicant,Admitted,錄取
-apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +116,Amount After Depreciation,折舊金額後
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,即將到來的日曆事件
-apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1,Variant Attributes,變量屬性
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +114,Please select month and year,請選擇年份和月份
-DocType: Employee,Company Email,企業郵箱
-DocType: GL Entry,Debit Amount in Account Currency,在科目幣種借記金額
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,訂單價值
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,訂單價值
-DocType: Certified Consultant,Certified Consultant,認證顧問
-apps/erpnext/erpnext/config/accounts.py +29,Bank/Cash transactions against party or for internal transfer,銀行/現金對一方或內部轉讓交易
-DocType: Shipping Rule,Valid for Countries,有效的國家
-apps/erpnext/erpnext/stock/doctype/item/item.js +57,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,這個項目是一個模板，並且可以在交易不能使用。項目的屬性將被複製到變型，除非“不複製”設置
-DocType: Grant Application,Grant Application,授予申請
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,總訂貨考慮
-DocType: Certification Application,Not Certified,未認證
-DocType: Asset Value Adjustment,New Asset Value,新資產價值
-DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,公司貨幣被換算成客戶基礎貨幣的匯率
-DocType: Course Scheduling Tool,Course Scheduling Tool,排課工具
-apps/erpnext/erpnext/controllers/accounts_controller.py +698,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},行＃{0}：採購發票不能對現有資產進行{1}
-DocType: Crop Cycle,LInked Analysis,LInked分析
-DocType: POS Closing Voucher,POS Closing Voucher,POS關閉憑證
-DocType: Contract,Lapsed,失效
-DocType: Item Tax,Tax Rate,稅率
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +107,Application period cannot be across two allocation records,申請期限不能跨越兩個分配記錄
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +73,{0} already allocated for Employee {1} for period {2} to {3},{0}已分配給員工{1}週期為{2}到{3}
-DocType: Buying Settings,Backflush Raw Materials of Subcontract Based On,基於CRM的分包合同反向原材料
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +145,Purchase Invoice {0} is already submitted,採購發票{0}已經提交
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +90,Row # {0}: Batch No must be same as {1} {2},行＃{0}：批號必須與{1} {2}
-DocType: Material Request Plan Item,Material Request Plan Item,材料申請計劃項目
-DocType: Leave Type,Allow Encashment,允許封裝
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +101,Convert to non-Group,轉換為非集團
-DocType: Project Update,Good/Steady,好/穩定
-DocType: Bank Statement Transaction Invoice Item,Invoice Date,發票日期
-DocType: GL Entry,Debit Amount,借方金額
-apps/erpnext/erpnext/accounts/party.py +277,There can only be 1 Account per Company in {0} {1},只能有每公司1科目{0} {1}
-DocType: Support Search Source,Response Result Key Path,響應結果關鍵路徑
-DocType: Journal Entry,Inter Company Journal Entry,Inter公司日記帳分錄
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +534,For quantity {0} should not be grater than work order quantity {1},數量{0}不應超過工單數量{1}
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +524,Please see attachment,請參閱附件
-DocType: Purchase Order,% Received,％ 已收
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,創建挺起胸
-DocType: Volunteer,Weekends,週末
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +138,Credit Note Amount,信用額度
-DocType: Setup Progress Action,Action Document,行動文件
-DocType: Chapter Member,Website URL,網站網址
-DocType: Delivery Note,Instructions,說明
-DocType: Quality Inspection,Inspected By,檢查
-DocType: Asset Maintenance Log,Maintenance Type,維護類型
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45,{0} - {1} is not enrolled in the Course {2},{0}  -  {1} 未在課程中註冊 {2}
-apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +225,Student Name: ,學生姓名：
-DocType: POS Closing Voucher Details,Difference,區別
-DocType: Delivery Settings,Delay between Delivery Stops,交貨停止之間的延遲
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},序列號{0}不屬於送貨單{1}
-apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +97,"There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.",服務器的GoCardless配置似乎存在問題。別擔心，如果失敗，這筆款項將退還給您的帳戶。
-apps/erpnext/erpnext/public/js/utils/item_selector.js +20,Add Items,添加項目
-DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,產品質量檢驗參數
-DocType: Leave Application,Leave Approver Name,離開批准人姓名
-DocType: Depreciation Schedule,Schedule Date,排定日期
-DocType: Packed Item,Packed Item,盒裝產品
-DocType: Job Offer Term,Job Offer Term,招聘條件
-apps/erpnext/erpnext/config/buying.py +65,Default settings for buying transactions.,採購交易的預設設定。
-apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},存在活動費用為員工{0}對活動類型 -  {1}
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +20,Mandatory field - Get Students From,強制性領域 - 獲得學生
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +20,Mandatory field - Get Students From,強制性領域 - 獲得學生
-DocType: Program Enrollment,Enrolled courses,入學課程
-DocType: Program Enrollment,Enrolled courses,入學課程
-DocType: Currency Exchange,Currency Exchange,外幣兌換
-DocType: Opening Invoice Creation Tool Item,Item Name,項目名稱
-DocType: Authorization Rule,Approving User  (above authorized value),批准的用戶（上述授權值）
-DocType: Email Digest,Credit Balance,貸方餘額
-DocType: Employee,Widowed,寡
-DocType: Request for Quotation,Request for Quotation,詢價
-DocType: Healthcare Settings,Require Lab Test Approval,需要實驗室測試批准
-DocType: Salary Slip Timesheet,Working Hours,工作時間
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +10,Total Outstanding,總計傑出
-DocType: Naming Series,Change the starting / current sequence number of an existing series.,更改現有系列的開始/當前的序列號。
-DocType: Dosage Strength,Strength,強度
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1548,Create a new Customer,創建一個新的客戶
-apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py +17,Expiring On,即將到期
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.",如果有多個定價規則繼續有效，用戶將被要求手動設定優先順序來解決衝突。
-apps/erpnext/erpnext/utilities/activation.py +90,Create Purchase Orders,創建採購訂單
-,Purchase Register,購買註冊
-DocType: Scheduling Tool,Rechedule,Rechedule
-DocType: Landed Cost Item,Applicable Charges,相關費用
-DocType: Purchase Receipt,Vehicle Date,車日期
-DocType: Student Log,Medical,醫療
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +186,Reason for losing,原因丟失
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1757,Please select Drug,請選擇藥物
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +44,Lead Owner cannot be same as the Lead,主導所有人不能等同於主導者
-apps/erpnext/erpnext/accounts/utils.py +380,Allocated amount can not greater than unadjusted amount,分配的金額不能超過未調整的量更大
-DocType: Location,Area UOM,區域UOM
-apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,Workstation is closed on the following dates as per Holiday List: {0},工作站在以下日期關閉按假日列表：{0}
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +34,Opportunities,機會
-DocType: Lab Test Template,Single,單
-DocType: Compensatory Leave Request,Work From Date,從日期開始工作
-DocType: Salary Slip,Total Loan Repayment,總貸款還款
-DocType: Account,Cost of Goods Sold,銷貨成本
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +231,Please enter Cost Center,請輸入成本中心
-DocType: Drug Prescription,Dosage,劑量
-DocType: Journal Entry Account,Sales Order,銷售訂單
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +67,Avg. Selling Rate,平均。賣出價
-DocType: Assessment Plan,Examiner Name,考官名稱
-DocType: Lab Test Template,No Result,沒有結果
-DocType: Purchase Invoice Item,Quantity and Rate,數量和速率
-DocType: Delivery Note,% Installed,％已安裝
-apps/erpnext/erpnext/utilities/user_progress.py +230,Classrooms/ Laboratories etc where lectures can be scheduled.,教室/實驗室等在那裡的演講可以預定。
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1308,Company currencies of both the companies should match for Inter Company Transactions.,兩家公司的公司貨幣應該符合Inter公司交易。
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +95,Please enter company name first,請先輸入公司名稱
-DocType: Travel Itinerary,Non-Vegetarian,非素食主義者
-DocType: Purchase Invoice,Supplier Name,供應商名稱
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25,Read the ERPNext Manual,閱讀ERPNext手冊
-DocType: HR Settings,Show Leaves Of All Department Members In Calendar,在日曆中顯示所有部門成員的葉子
-DocType: Purchase Invoice,01-Sales Return,01-銷售退貨
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +15,Temporarily on Hold,暫時擱置
-DocType: Account,Is Group,是集團
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +327,Credit Note {0} has been created automatically,信用票據{0}已自動創建
-DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,自動設置序列號的基礎上FIFO
-DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,檢查供應商發票編號唯一性
-apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34,Primary Address Details,主要地址詳情
-DocType: Vehicle Service,Oil Change,換油
-DocType: Leave Encashment,Leave Balance,保持平衡
-DocType: Asset Maintenance Log,Asset Maintenance Log,資產維護日誌
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.',“至案件編號”不能少於'從案件編號“
-DocType: Certification Application,Non Profit,非營利
-DocType: Production Plan,Not Started,未啟動
-DocType: Lead,Channel Partner,渠道合作夥伴
-DocType: Account,Old Parent,舊上級
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +24,Mandatory field - Academic Year,必修課 - 學年
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +24,Mandatory field - Academic Year,必修課 - 學年
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +221,{0} {1} is not associated with {2} {3},{0} {1} 未與 {2} {3} 關聯
-DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,自定義去作為郵件的一部分的介紹文字。每筆交易都有一個單獨的介紹性文字。
-apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py +56,Row {0} : Operation is required against the raw material item {1},行{0}：對原材料項{1}需要操作
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +180,Please set default payable account for the company {0},請為公司{0}設置預設應付帳款
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +608,Transaction not allowed against stopped Work Order {0},不允許對停止的工單{0}進行交易
-DocType: Setup Progress Action,Min Doc Count,最小文件計數
-apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,所有製造過程中的全域設定。
-DocType: Accounts Settings,Accounts Frozen Upto,科目被凍結到
-DocType: SMS Log,Sent On,發送於
-apps/erpnext/erpnext/stock/doctype/item/item.py +778,Attribute {0} selected multiple times in Attributes Table,屬性{0}多次選擇在屬性表
-DocType: HR Settings,Employee record is created using selected field. ,使用所選欄位創建員工記錄。
-DocType: Sales Order,Not Applicable,不適用
-DocType: Amazon MWS Settings,UK,聯合王國
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +85,Opening Invoice Item,打開發票項目
-DocType: Request for Quotation Item,Required Date,所需時間
-DocType: Delivery Note,Billing Address,帳單地址
-DocType: Bank Statement Settings,Statement Headers,聲明標題
-DocType: Tax Rule,Billing County,開票縣
-DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount",如果選中，稅額將被視為已包含在列印速率/列印數量
-DocType: Request for Quotation,Message for Supplier,消息供應商
-DocType: Job Card,Work Order,工作指示
-DocType: Sales Invoice,Total Qty,總數量
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2電子郵件ID
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2電子郵件ID
-DocType: Item,Show in Website (Variant),展網站（變體）
-DocType: Employee,Health Concerns,健康問題
-DocType: Payroll Entry,Select Payroll Period,選擇工資期
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49,Reserved for sale,保留出售
-DocType: Packing Slip,From Package No.,從包裹編號
-DocType: Item Attribute,To Range,為了範圍
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Securities and Deposits,證券及存款
-apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +48,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method",不能改變估值方法，因為有一些項目沒有自己的估值方法的交易
-DocType: Student Report Generation Tool,Attended by Parents,由父母出席
-apps/erpnext/erpnext/hr/doctype/shift_assignment/shift_assignment.py +39,Employee {0} has already applied for {1} on {2} : ,員工{0}已在{2}上申請{1}：
-DocType: Inpatient Record,AB Positive,AB積極
-DocType: Job Opening,Description of a Job Opening,一個空缺職位的說明
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +118,Pending activities for today,今天待定活動
-DocType: Salary Structure,Salary Component for timesheet based payroll.,薪酬部分基於時間表工資。
-DocType: Driver,Applicable for external driver,適用於外部驅動器
-DocType: Sales Order Item,Used for Production Plan,用於生產計劃
-DocType: Loan,Total Payment,總付款
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +117,Cannot cancel transaction for Completed Work Order.,無法取消已完成工單的交易。
-DocType: Manufacturing Settings,Time Between Operations (in mins),作業間隔時間（以分鐘計）
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +837,PO already created for all sales order items,已為所有銷售訂單項創建採購訂單
-DocType: Healthcare Service Unit,Occupied,佔據
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +130,{0} {1} is cancelled so the action cannot be completed,{0} {1} 被取消，因此無法完成操作
-DocType: Customer,Buyer of Goods and Services.,買家商品和服務。
-DocType: Journal Entry,Accounts Payable,應付帳款
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +55,The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,此付款申請中設置的{0}金額與所有付款計劃的計算金額不同：{1}。在提交文檔之前確保這是正確的。
-DocType: Patient,Allergies,過敏
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +43,The selected BOMs are not for the same item,所選的材料清單並不同樣項目
-apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js +32,Change Item Code,更改物料代碼
-DocType: Vital Signs,Blood Pressure (systolic),血壓（收縮期）
-DocType: Item Price,Valid Upto,到...為止有效
-DocType: Training Event,Workshop,作坊
-DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,警告採購訂單
-apps/erpnext/erpnext/utilities/user_progress.py +67,List a few of your customers. They could be organizations or individuals.,列出一些你的客戶。他們可以是組織或個人。
-DocType: Employee Tax Exemption Proof Submission,Rented From Date,從日期租用
-apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +25,Enough Parts to Build,足夠的配件組裝
-DocType: POS Profile User,POS Profile User,POS配置文件用戶
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +194,Row {0}: Depreciation Start Date is required,行{0}：折舊開始日期是必需的
-DocType: Purchase Invoice Item,Service Start Date,服務開始日期
-DocType: Subscription Invoice,Subscription Invoice,訂閱發票
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +135,Direct Income,直接收入
-DocType: Patient Appointment,Date TIme,約會時間
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +53,"Can not filter based on Account, if grouped by Account",7 。總計：累積總數達到了這一點。
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +93,Administrative Officer,政務主任
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40,Setting up company and taxes,建立公司和稅收
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,請選擇課程
-DocType: Codification Table,Codification Table,編纂表
-DocType: Timesheet Detail,Hrs,小時
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +410,Please select Company,請選擇公司
-DocType: Stock Entry Detail,Difference Account,差異科目
-DocType: Purchase Invoice,Supplier GSTIN,供應商GSTIN
-apps/erpnext/erpnext/projects/doctype/task/task.py +50,Cannot close task as its dependant task {0} is not closed.,不能因為其依賴的任務{0}沒有關閉關閉任務。
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +435,Please enter Warehouse for which Material Request will be raised,請輸入物料需求欲增加的倉庫
-DocType: Work Order,Additional Operating Cost,額外的運營成本
-DocType: Lab Test Template,Lab Routine,實驗室常規
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20,Cosmetics,化妝品
-apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18,Please select Completion Date for Completed Asset Maintenance Log,請選擇已完成資產維護日誌的完成日期
-apps/erpnext/erpnext/stock/doctype/item/item.py +583,"To merge, following properties must be same for both items",若要合併，以下屬性必須為這兩個項目是相同的
-DocType: Supplier,Block Supplier,塊供應商
-DocType: Shipping Rule,Net Weight,淨重
-DocType: Job Opening,Planned number of Positions,計劃的職位數量
-DocType: Employee,Emergency Phone,緊急電話
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82,{0} {1} does not exist.,{0} {1} 不存在。
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,購買
-,Serial No Warranty Expiry,序列號保修到期
-DocType: Sales Invoice,Offline POS Name,離線POS名稱
-apps/erpnext/erpnext/utilities/user_progress.py +180,Student Application,學生申請
-DocType: Bank Statement Transaction Payment Item,Payment Reference,付款憑據
-DocType: Supplier,Hold Type,保持類型
-apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,請定義等級為閾值0％
-apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,請定義等級為閾值0％
-DocType: Bank Statement Transaction Payment Item,Bank Statement Transaction Payment Item,銀行對賬單交易付款項目
-DocType: Sales Order,To Deliver,為了提供
-DocType: Purchase Invoice Item,Item,項目
-apps/erpnext/erpnext/healthcare/setup.py +188,High Sensitivity,高靈敏度
-apps/erpnext/erpnext/config/non_profit.py +48,Volunteer Type information.,志願者類型信息。
-DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,現金流量映射模板
-DocType: Travel Request,Costing Details,成本計算詳情
-apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.js +64,Show Return Entries,顯示返回條目
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2569,Serial no item cannot be a fraction,序號項目不能是一個分數
-DocType: Journal Entry,Difference (Dr - Cr),差異（Dr - Cr）
-DocType: Account,Profit and Loss,損益
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +99,"Not permitted, configure Lab Test Template as required",不允許，根據需要配置實驗室測試模板
-DocType: Patient,Risk Factors,風險因素
-DocType: Patient,Occupational Hazards and Environmental Factors,職業危害與環境因素
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +321,Stock Entries already created for Work Order ,已為工單創建的庫存條目
-DocType: Vital Signs,Respiratory rate,呼吸頻率
-apps/erpnext/erpnext/config/stock.py +337,Managing Subcontracting,管理轉包
-DocType: Vital Signs,Body Temperature,體溫
-DocType: Project,Project will be accessible on the website to these users,項目將在網站向這些用戶上訪問
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +292,Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},無法取消{0} {1}，因為序列號{2}不屬於倉庫{3}
-DocType: Company,Default Deferred Expense Account,默認遞延費用科目
-apps/erpnext/erpnext/config/projects.py +29,Define Project type.,定義項目類型。
-DocType: Supplier Scorecard,Weighting Function,加權函數
-DocType: Healthcare Practitioner,OP Consulting Charge,OP諮詢費
-apps/erpnext/erpnext/utilities/user_progress.py +28,Setup your ,設置你的
-DocType: Student Report Generation Tool,Show Marks,顯示標記
-DocType: Support Settings,Get Latest Query,獲取最新查詢
-DocType: Quotation,Rate at which Price list currency is converted to company's base currency,價目表貨幣被換算成公司基礎貨幣的匯率
-apps/erpnext/erpnext/setup/doctype/company/company.py +74,Account {0} does not belong to company: {1},科目{0}不屬於公司：{1}
-apps/erpnext/erpnext/setup/doctype/company/company.py +56,Abbreviation already used for another company,另一家公司已使用此縮寫
-DocType: Selling Settings,Default Customer Group,預設客戶群組
-DocType: Employee,IFSC Code,IFSC代碼
-DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction",如果禁用，“圓角總計”字段將不可見的任何交易
-DocType: BOM,Operating Cost,營業成本
-DocType: Crop,Produced Items,生產物品
-DocType: Bank Statement Transaction Entry,Match Transaction to Invoices,將交易與發票匹配
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +872,Unblock Invoice,取消屏蔽發票
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,增量不能為0
-DocType: Company,Delete Company Transactions,刪除公司事務
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +366,Reference No and Reference Date is mandatory for Bank transaction,參考編號和參考日期是強制性的銀行交易
-DocType: Purchase Receipt,Add / Edit Taxes and Charges,新增 / 編輯稅金及費用
-DocType: Payment Entry Reference,Supplier Invoice No,供應商發票號碼
-DocType: Territory,For reference,供參考
-DocType: Healthcare Settings,Appointment Confirmation,預約確認
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"Cannot delete Serial No {0}, as it is used in stock transactions",無法刪除序列號{0}，因為它採用的是現貨交易
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +278,Closing (Cr),關閉（Cr）
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118,Move Item,移動項目
-DocType: Employee Incentive,Incentive Amount,激勵金額
-DocType: Serial No,Warranty Period (Days),保修期限（天數）
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +76,Total Credit/ Debit Amount should be same as linked Journal Entry,總信用/借方金額應與鏈接的日記帳分錄相同
-DocType: Installation Note Item,Installation Note Item,安裝注意項
-DocType: Production Plan Item,Pending Qty,待定數量
-apps/erpnext/erpnext/accounts/party.py +429,{0} {1} is not active,{0} {1}是不活動
-DocType: Woocommerce Settings,Freight and Forwarding Account,貨運和轉運科目
-apps/erpnext/erpnext/config/accounts.py +240,Setup cheque dimensions for printing,設置檢查尺寸打印
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +33,Create Salary Slips,創建工資單
-DocType: Vital Signs,Bloated,脹
-DocType: Salary Slip,Salary Slip Timesheet,工資單時間表
-apps/erpnext/erpnext/controllers/buying_controller.py +200,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,對於轉包的採購入庫單，供應商倉庫是強制性輸入的。
-DocType: Sales Invoice,Total Commission,佣金總計
-DocType: Tax Withholding Account,Tax Withholding Account,扣繳稅款科目
-DocType: Pricing Rule,Sales Partner,銷售合作夥伴
-apps/erpnext/erpnext/config/buying.py +150,All Supplier scorecards.,所有供應商記分卡。
-DocType: Buying Settings,Purchase Receipt Required,需要採購入庫單
-DocType: Delivery Note,Rail,軌
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +267,Target warehouse in row {0} must be same as Work Order,行{0}中的目標倉庫必須與工單相同
-apps/erpnext/erpnext/stock/doctype/item/item.py +183,Valuation Rate is mandatory if Opening Stock entered,估價費用是強制性的，如果打開庫存進入
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +143,No records found in the Invoice table,沒有在發票表中找到記錄
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +36,Please select Company and Party Type first,請選擇公司和黨的第一型
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31,"Already set default in pos profile {0} for user {1}, kindly disabled default",已經在用戶{1}的pos配置文件{0}中設置了默認值，請禁用默認值
-apps/erpnext/erpnext/config/accounts.py +261,Financial / accounting year.,財務／會計年度。
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,累積值
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +166,"Sorry, Serial Nos cannot be merged",對不起，序列號無法合併
-DocType: Shopify Settings,Customer Group will set to selected group while syncing customers from Shopify,客戶組將在同步Shopify客戶的同時設置為選定的組
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72,Territory is Required in POS Profile,POS Profile中需要領域
-DocType: Hub User,Hub User,中心用戶
-apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,製作銷售訂單
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +541,Salary Slip submitted for period from {0} to {1},從{0}到{1}
-DocType: Project Task,Project Task,項目任務
-DocType: Loyalty Point Entry Redemption,Redeemed Points,兌換積分
-,Lead Id,潛在客戶標識
-DocType: C-Form Invoice Detail,Grand Total,累計
-DocType: Assessment Plan,Course,課程
-apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py +105,Section Code,部分代碼
-DocType: Timesheet,Payslip,工資單
-apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py +18,Half day date should be in between from date and to date,半天的日期應該在從日期到日期之間
-apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,項目車
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38,Fiscal Year Start Date should not be greater than Fiscal Year End Date,會計年度開始日期應不大於財政年度結束日期
-DocType: Issue,Resolution,決議
-DocType: Employee,Personal Bio,個人自傳
-apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py +15,Membership ID,會員ID
-apps/erpnext/erpnext/templates/pages/order.html +77,Delivered: {0},交貨：{0}
-DocType: QuickBooks Migrator,Connected to QuickBooks,連接到QuickBooks
-DocType: Bank Statement Transaction Entry,Payable Account,應付帳款
-DocType: Payment Entry,Type of Payment,付款類型
-apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +18,Half Day Date is mandatory,半天日期是強制性的
-DocType: Sales Order,Billing and Delivery Status,結算和交貨狀態
-DocType: Job Applicant,Resume Attachment,簡歷附
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,回頭客
-apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108,Create Variant,創建變體
-DocType: Sales Invoice,Shipping Bill Date,運費單日期
-DocType: Production Plan,Production Plan,生產計劃
-DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,打開發票創建工具
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +909,Sales Return,銷貨退回
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +110,Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,注：總分配葉{0}應不低於已核定葉{1}期間
-DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,根據序列號輸入設置交易數量
-,Total Stock Summary,總庫存總結
-apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py +68,"You can only plan for upto {0} vacancies and budget {1} \
+At least one mode of payment is required for POS invoice.,付款中的至少一個模式需要POS發票。
+Bank Statement Transaction Invoice Item,銀行對賬單交易發票項目
+Show Products as a List,產品展示作為一個列表
+Tax on flexible benefit,對靈活福利徵稅
+Item {0} is not active or end of life has been reached,項目{0}不活躍或生命的盡頭已經達到
+Minimum Age,最低年齡
+Example: Basic Mathematics,例如：基礎數學
+Diff Qty,差異數量
+Material Request Detail,材料請求詳情
+Default Quotation Validity Days,默認報價有效天數
+"To include tax in row {0} in Item rate, taxes in rows {1} must also be included",要包括稅款，行{0}項率，稅收行{1}也必須包括在內
+Validate Attendance,驗證出席
+Change Amount,變動金額
+Certificate Received,已收到證書
+Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,設置B2C的發票值。 B2CL和B2CS根據此發票值計算。
+New BOM,新的物料清單
+Prescribed Procedures,規定程序
+Show only POS,只顯示POS,
+Supplier Group Name,供應商集團名稱
+Driving License Categories,駕駛執照類別
+Please enter Delivery Date,請輸入交貨日期
+Make Depreciation Entry,計提折舊進入
+Closed Document,關閉文件
+Leave Settings,保留設置
+Number of positions cannot be less then current count of employees,職位數量不能少於當前員工人數
+Request Type,請求類型
+Purpose of Travel,旅行目的
+Payroll Periods,工資期間
+Make Employee,使員工
+Broadcasting,廣播
+Setup mode of POS (Online / Offline),POS（在線/離線）的設置模式
+Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order,禁止根據工作訂單創建時間日誌。不得根據工作指令跟踪操作
+Execution,執行
+Details of the operations carried out.,進行的作業細節。
+Maintenance Status,維修狀態
+Membership Details,會員資格
+{0} {1}: Supplier is required against Payable account {2},{0} {1}：需要對供應商應付帳款{2}
+Items and Pricing,項目和定價
+Total hours: {0},總時間：{0}
+From Date should be within the Fiscal Year. Assuming From Date = {0},從日期應該是在財政年度內。假設起始日期＝{0}
+Interval,間隔
+Preference,偏愛
+Individual,個人
+Academics User,學術界用戶
+Amount In Figure,量圖
+Loan Info,貸款信息
+Plan for maintenance visits.,規劃維護訪問。
+Supplier Scorecard Period,供應商記分卡期
+Share Transfer,股份轉讓
+Expiring Memberships,即將到期的會員
+Customer Groups,客戶群
+Financial Statements,財務報表
+Students,學生們
+Rules for applying pricing and discount.,規則適用的定價和折扣。
+Daily Work Summary Group,日常工作總結小組
+Time Slots,時隙
+Price List must be applicable for Buying or Selling,價格表必須適用於購買或出售
+Shift Request,移位請求
+Installation date cannot be before delivery date for Item {0},品項{0}的安裝日期不能早於交貨日期
+Discount on Price List Rate (%),折扣價目表率（％）
+Item Template,項目模板
+Select Terms and Conditions,選擇條款和條件
+Out Value,輸出值
+Bank Statement Settings Item,銀行對賬單設置項目
+Woocommerce Settings,Woocommerce設置
+Sales Orders,銷售訂單
+Multiple Loyalty Program found for the Customer. Please select manually.,為客戶找到多個忠誠度計劃。請手動選擇。
+Valuation,計價
+Set as Default,設為預設
+Purchase Order Trends,採購訂單趨勢
+Go to Customers,轉到客戶
+Late Checkin,延遲入住
+The request for quotation can be accessed by clicking on the following link,報價請求可以通過點擊以下鏈接進行訪問
+SG Creation Tool Course,SG創建工具課程
+Payment Description,付款說明
+Insufficient Stock,庫存不足
+Disable Capacity Planning and Time Tracking,禁用產能規劃和時間跟踪
+New Sales Orders,新的銷售訂單
+Bank Account,銀行帳戶
+Check-out Date,離開日期
+Allow Negative Balance,允許負平衡
+You cannot delete Project Type 'External',您不能刪除項目類型“外部”
+Select Alternate Item,選擇備用項目
+Create User,創建用戶
+Default Territory,預設地域
+Television,電視
+Updated via 'Time Log',經由“時間日誌”更新
+Select the customer or supplier.,選擇客戶或供應商。
+Advance amount cannot be greater than {0} {1},提前量不能大於{0} {1}
+"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}",時隙滑動，時隙{0}到{1}與現有時隙{2}重疊到{3}
+Series List for this Transaction,本交易系列表
+Enable Perpetual Inventory,啟用永久庫存
+Charges Incurred,收費發生
+Default Payroll Payable Account,默認情況下，應付職工薪酬帳戶
+Update Email Group,更新電子郵件組
+Is Opening Entry,是開放登錄
+"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ",如果取消選中，該項目不會出現在銷售發票中，但可用於創建組測試。
+Mention if non-standard receivable account applicable,何況，如果不規範應收帳款適用
+Instructor Name,導師姓名
+Arrear Component,欠費組件
+Criteria Setup,條件設置
+For Warehouse is required before Submit,對於倉庫之前，需要提交
+Medical Code,醫療代號
+Connect Amazon with ERPNext,將Amazon與ERPNext連接起來
+Please enter Company,請輸入公司名稱
+Against Sales Invoice Item,對銷售發票項目
+Linked Doctype,鏈接的文檔類型
+Net Cash from Financing,從融資淨現金
+"LocalStorage is full , did not save",localStorage的滿了，沒救
+Address & Contact,地址及聯絡方式
+Add unused leaves from previous allocations,從以前的分配添加未使用的休假
+Partner website,合作夥伴網站
+Add Item,新增項目
+Party Tax Withholding Config,黨的預扣稅配置
+Custom Result,自定義結果
+Contact Name,聯絡人姓名
+Course Assessment Criteria,課程評價標準
+Tax Id: ,稅號：
+Student ID: ,學生卡：
+POS Customer Group,POS客戶群
+Practitioner Schedules,從業者時間表
+Additional Details,額外細節
+Request for purchase.,請求您的報價。
+Collected Amount,收集金額
+This is based on the Time Sheets created against this project,這是基於對這個項目產生的考勤表
+Open Work Orders,打開工作訂單
+Out Patient Consulting Charge Item,出患者諮詢費用項目
+Credit Months,信貸月份
+Net Pay cannot be less than 0,淨工資不能低於0,
+Fulfilled,達到
+Discharge Scheduled,出院預定
+Relieving Date must be greater than Date of Joining,解除日期必須大於加入的日期
+Cashier,出納員
+Leaves per Year,每年葉
+Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,行{0}：請檢查'是進階'對科目{1}，如果這是一個進階條目。
+Warehouse {0} does not belong to company {1},倉庫{0}不屬於公司{1}
+Profit & Loss,收益與損失
+Total Costing Amount (via Time Sheet),總成本計算量（通過時間表）
+Please setup Students under Student Groups,請設置學生組的學生
+Item Website Specification,項目網站規格
+Leave Blocked,禁假的
+Item {0} has reached its end of life on {1},項{0}已達到其壽命結束於{1}
+Bank Entries,銀行條目
+Is Internal Customer,是內部客戶
+"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)",如果選中自動選擇，則客戶將自動與相關的忠誠度計劃鏈接（保存時）
+Stock Reconciliation Item,庫存調整項目
+Sales Invoice No,銷售發票號碼
+Supply Type,供應類型
+Min Order Qty,最小訂貨量
+Student Group Creation Tool Course,學生組創建工具課程
+Do Not Contact,不要聯絡
+People who teach at your organisation,誰在您的組織教人
+Software Developer,軟件開發人員
+Minimum Order Qty,最低起訂量
+Supplier Type,供應商類型
+Course Start Date,課程開始日期
+Student Batch-Wise Attendance,學生分批出席
+Allow user to edit Rate,允許用戶編輯率
+Publish in Hub,在發布中心
+Student Admission,學生入學
+Terretory,Terretory,
+Item {0} is cancelled,項{0}將被取消
+Depreciation Row {0}: Depreciation Start Date is entered as past date,折舊行{0}：折舊開始日期作為過去的日期輸入
+Fulfilment Terms and Conditions,履行條款和條件
+Material Request,物料需求
+Update Clearance Date,更新日期間隙
+Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},項目{0}未發現“原材料提供&#39;表中的採購訂單{1}
+Total Principal Amount,本金總額
+Relation,關係
+Mother,母親
+Reservation End Time,預訂結束時間
+Biennial,雙年展
+BOM Variance Report,BOM差異報告
+Confirmed orders from Customers.,確認客戶的訂單。
+Rejected Quantity,拒絕數量
+Payment request {0} created,已創建付款請求{0}
+Admitted Datetime,承認日期時間
+Backflush raw materials from work-in-progress warehouse,從在製品庫中反沖原料
+Open Orders,開放訂單
+Low Sensitivity,低靈敏度
+Order rescheduled for sync,訂單重新安排同步
+Please confirm once you have completed your training,完成培訓後請確認
+Suggestions,建議
+Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,在此地域設定跨群組項目間的預算。您還可以通過設定分配來包含季節性。
+Payment Term Name,付款條款名稱
+Create documents for sample collection,創建樣本收集文件
+Payment against {0} {1} cannot be greater than Outstanding Amount {2},對支付{0} {1}不能大於未償還{2}
+All Healthcare Service Units,所有醫療服務單位
+Mobile No.,手機號碼
+Generate Schedule,生成時間表
+Expense Head,總支出
+Please select Charge Type first,請先選擇付款類別
+"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ",你可以在這裡定義所有需要進行的作業。日場是用來提及任務需要執行的日子，1日是第一天等。
+Student Group Student,學生組學生
+Education Settings,教育設置
+Inspection,檢查
+Balance In Base Currency,平衡基礎貨幣
+Max Grade,最高等級
+New Quotations,新報價
+Attendance not submitted for {0} as {1} on leave.,在{0}上沒有針對{1}上的考勤出席。
+Payment Order,付款單
+Emails salary slip to employee based on preferred email selected in Employee,電子郵件工資單員工根據員工選擇首選的電子郵件
+Shipping County,航運縣
+Learn,學習
+Enable Deferred Expense,啟用延期費用
+Next Depreciation Date,接下來折舊日期
+Activity Cost per Employee,每個員工活動費用
+Settings for Accounts,會計設定
+Supplier Invoice No exists in Purchase Invoice {0},供應商發票不存在採購發票{0}
+Manage Sales Person Tree.,管理銷售人員樹。
+"Cannot process route, since Google Maps Settings is disabled.",由於禁用了Google地圖設置，因此無法處理路線。
+Cover Letter,求職信
+Outstanding Cheques and Deposits to clear,傑出的支票及存款清除
+Synced With Hub,同步轂
+Fleet Manager,車隊經理
+Row #{0}: {1} can not be negative for item {2},行＃{0}：{1}不能為負值對項{2}
+Wrong Password,密碼錯誤
+Variant Of,變種
+Completed Qty can not be greater than 'Qty to Manufacture',完成數量不能大於“數量來製造”
+Closing Account Head,關閉帳戶頭
+External Work History,外部工作經歷
+Circular Reference Error,循環引用錯誤
+Student Report Card,學生報告卡
+From Pin Code,來自Pin Code,
+Guardian1 Name,Guardian1名稱
+In Words (Export) will be visible once you save the Delivery Note.,送貨單一被儲存，(Export)就會顯示出來。
+Distance from left edge,從左側邊緣的距離
+{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} [{1}]的單位（＃窗體/項目/ {1}）在[{2}]研究發現（＃窗體/倉儲/ {2}）
+Industry,行業
+Rate & Amount,價格和金額
+Transfer Material Against Job Card,轉移材料反對工作卡
+Notify by Email on creation of automatic Material Request,在建立自動材料需求時以電子郵件通知
+Please set Hotel Room Rate on {},請在{}上設置酒店房價
+Multi Currency,多幣種
+Invoice Type,發票類型
+Expense Proof,費用證明
+Delivery Note,送貨單
+Setting up Taxes,建立稅
+Cost of Sold Asset,出售資產的成本
+Payment Entry has been modified after you pulled it. Please pull it again.,付款項被修改，你把它之後。請重新拉。
+New Student Batch,新學生批次
+{0} entered twice in Item Tax,{0}輸入兩次項目稅
+Summary for this week and pending activities,本週和待活動總結
+Admitted,錄取
+Amount After Depreciation,折舊金額後
+Upcoming Calendar Events,即將到來的日曆事件
+Variant Attributes,變量屬性
+Please select month and year,請選擇年份和月份
+Company Email,企業郵箱
+Debit Amount in Account Currency,在科目幣種借記金額
+Order Value,訂單價值
+Order Value,訂單價值
+Certified Consultant,認證顧問
+Bank/Cash transactions against party or for internal transfer,銀行/現金對一方或內部轉讓交易
+Valid for Countries,有效的國家
+This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,這個項目是一個模板，並且可以在交易不能使用。項目的屬性將被複製到變型，除非“不複製”設置
+Grant Application,授予申請
+Total Order Considered,總訂貨考慮
+Not Certified,未認證
+New Asset Value,新資產價值
+Rate at which Customer Currency is converted to customer's base currency,公司貨幣被換算成客戶基礎貨幣的匯率
+Course Scheduling Tool,排課工具
+Row #{0}: Purchase Invoice cannot be made against an existing asset {1},行＃{0}：採購發票不能對現有資產進行{1}
+LInked Analysis,LInked分析
+POS Closing Voucher,POS關閉憑證
+Lapsed,失效
+Tax Rate,稅率
+Application period cannot be across two allocation records,申請期限不能跨越兩個分配記錄
+{0} already allocated for Employee {1} for period {2} to {3},{0}已分配給員工{1}週期為{2}到{3}
+Backflush Raw Materials of Subcontract Based On,基於CRM的分包合同反向原材料
+Purchase Invoice {0} is already submitted,採購發票{0}已經提交
+Row # {0}: Batch No must be same as {1} {2},行＃{0}：批號必須與{1} {2}
+Material Request Plan Item,材料申請計劃項目
+Allow Encashment,允許封裝
+Convert to non-Group,轉換為非集團
+Good/Steady,好/穩定
+Invoice Date,發票日期
+Debit Amount,借方金額
+There can only be 1 Account per Company in {0} {1},只能有每公司1科目{0} {1}
+Response Result Key Path,響應結果關鍵路徑
+Inter Company Journal Entry,Inter公司日記帳分錄
+For quantity {0} should not be grater than work order quantity {1},數量{0}不應超過工單數量{1}
+Please see attachment,請參閱附件
+% Received,％ 已收
+Create Student Groups,創建挺起胸
+Weekends,週末
+Credit Note Amount,信用額度
+Action Document,行動文件
+Website URL,網站網址
+Instructions,說明
+Inspected By,檢查
+Maintenance Type,維護類型
+{0} - {1} is not enrolled in the Course {2},{0}  -  {1} 未在課程中註冊 {2}
+Student Name: ,學生姓名：
+Difference,區別
+Delay between Delivery Stops,交貨停止之間的延遲
+Serial No {0} does not belong to Delivery Note {1},序列號{0}不屬於送貨單{1}
+"There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.",服務器的GoCardless配置似乎存在問題。別擔心，如果失敗，這筆款項將退還給您的帳戶。
+Add Items,添加項目
+Item Quality Inspection Parameter,產品質量檢驗參數
+Leave Approver Name,離開批准人姓名
+Schedule Date,排定日期
+Packed Item,盒裝產品
+Job Offer Term,招聘條件
+Default settings for buying transactions.,採購交易的預設設定。
+Activity Cost exists for Employee {0} against Activity Type - {1},存在活動費用為員工{0}對活動類型 -  {1}
+Mandatory field - Get Students From,強制性領域 - 獲得學生
+Mandatory field - Get Students From,強制性領域 - 獲得學生
+Enrolled courses,入學課程
+Enrolled courses,入學課程
+Currency Exchange,外幣兌換
+Item Name,項目名稱
+Approving User  (above authorized value),批准的用戶（上述授權值）
+Credit Balance,貸方餘額
+Widowed,寡
+Request for Quotation,詢價
+Require Lab Test Approval,需要實驗室測試批准
+Working Hours,工作時間
+Total Outstanding,總計傑出
+Change the starting / current sequence number of an existing series.,更改現有系列的開始/當前的序列號。
+Strength,強度
+Create a new Customer,創建一個新的客戶
+Expiring On,即將到期
+"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.",如果有多個定價規則繼續有效，用戶將被要求手動設定優先順序來解決衝突。
+Create Purchase Orders,創建採購訂單
+Purchase Register,購買註冊
+Rechedule,Rechedule,
+Applicable Charges,相關費用
+Vehicle Date,車日期
+Medical,醫療
+Reason for losing,原因丟失
+Please select Drug,請選擇藥物
+Lead Owner cannot be same as the Lead,主導所有人不能等同於主導者
+Allocated amount can not greater than unadjusted amount,分配的金額不能超過未調整的量更大
+Area UOM,區域UOM,
+Workstation is closed on the following dates as per Holiday List: {0},工作站在以下日期關閉按假日列表：{0}
+Opportunities,機會
+Single,單
+Work From Date,從日期開始工作
+Total Loan Repayment,總貸款還款
+Cost of Goods Sold,銷貨成本
+Please enter Cost Center,請輸入成本中心
+Dosage,劑量
+Sales Order,銷售訂單
+Avg. Selling Rate,平均。賣出價
+Examiner Name,考官名稱
+No Result,沒有結果
+Quantity and Rate,數量和速率
+% Installed,％已安裝
+Classrooms/ Laboratories etc where lectures can be scheduled.,教室/實驗室等在那裡的演講可以預定。
+Company currencies of both the companies should match for Inter Company Transactions.,兩家公司的公司貨幣應該符合Inter公司交易。
+Please enter company name first,請先輸入公司名稱
+Non-Vegetarian,非素食主義者
+Supplier Name,供應商名稱
+Read the ERPNext Manual,閱讀ERPNext手冊
+Show Leaves Of All Department Members In Calendar,在日曆中顯示所有部門成員的葉子
+01-Sales Return,01-銷售退貨
+Temporarily on Hold,暫時擱置
+Is Group,是集團
+Credit Note {0} has been created automatically,信用票據{0}已自動創建
+Automatically Set Serial Nos based on FIFO,自動設置序列號的基礎上FIFO,
+Check Supplier Invoice Number Uniqueness,檢查供應商發票編號唯一性
+Primary Address Details,主要地址詳情
+Oil Change,換油
+Leave Balance,保持平衡
+Asset Maintenance Log,資產維護日誌
+'To Case No.' cannot be less than 'From Case No.',“至案件編號”不能少於'從案件編號“
+Non Profit,非營利
+Not Started,未啟動
+Channel Partner,渠道合作夥伴
+Old Parent,舊上級
+Mandatory field - Academic Year,必修課 - 學年
+Mandatory field - Academic Year,必修課 - 學年
+{0} {1} is not associated with {2} {3},{0} {1} 未與 {2} {3} 關聯
+Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,自定義去作為郵件的一部分的介紹文字。每筆交易都有一個單獨的介紹性文字。
+Row {0} : Operation is required against the raw material item {1},行{0}：對原材料項{1}需要操作
+Please set default payable account for the company {0},請為公司{0}設置預設應付帳款
+Transaction not allowed against stopped Work Order {0},不允許對停止的工單{0}進行交易
+Min Doc Count,最小文件計數
+Global settings for all manufacturing processes.,所有製造過程中的全域設定。
+Accounts Frozen Upto,科目被凍結到
+Sent On,發送於
+Attribute {0} selected multiple times in Attributes Table,屬性{0}多次選擇在屬性表
+Employee record is created using selected field. ,使用所選欄位創建員工記錄。
+Not Applicable,不適用
+UK,聯合王國
+Opening Invoice Item,打開發票項目
+Required Date,所需時間
+Billing Address,帳單地址
+Statement Headers,聲明標題
+Billing County,開票縣
+"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount",如果選中，稅額將被視為已包含在列印速率/列印數量
+Message for Supplier,消息供應商
+Work Order,工作指示
+Total Qty,總數量
+Guardian2 Email ID,Guardian2電子郵件ID,
+Guardian2 Email ID,Guardian2電子郵件ID,
+Show in Website (Variant),展網站（變體）
+Health Concerns,健康問題
+Select Payroll Period,選擇工資期
+Reserved for sale,保留出售
+From Package No.,從包裹編號
+To Range,為了範圍
+Securities and Deposits,證券及存款
+"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method",不能改變估值方法，因為有一些項目沒有自己的估值方法的交易
+Attended by Parents,由父母出席
+Employee {0} has already applied for {1} on {2} : ,員工{0}已在{2}上申請{1}：
+AB Positive,AB積極
+Description of a Job Opening,一個空缺職位的說明
+Pending activities for today,今天待定活動
+Salary Component for timesheet based payroll.,薪酬部分基於時間表工資。
+Applicable for external driver,適用於外部驅動器
+Used for Production Plan,用於生產計劃
+Total Payment,總付款
+Cannot cancel transaction for Completed Work Order.,無法取消已完成工單的交易。
+Time Between Operations (in mins),作業間隔時間（以分鐘計）
+PO already created for all sales order items,已為所有銷售訂單項創建採購訂單
+Occupied,佔據
+{0} {1} is cancelled so the action cannot be completed,{0} {1} 被取消，因此無法完成操作
+Buyer of Goods and Services.,買家商品和服務。
+Accounts Payable,應付帳款
+The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,此付款申請中設置的{0}金額與所有付款計劃的計算金額不同：{1}。在提交文檔之前確保這是正確的。
+Allergies,過敏
+The selected BOMs are not for the same item,所選的材料清單並不同樣項目
+Change Item Code,更改物料代碼
+Blood Pressure (systolic),血壓（收縮期）
+Valid Upto,到...為止有效
+Workshop,作坊
+Warn Purchase Orders,警告採購訂單
+List a few of your customers. They could be organizations or individuals.,列出一些你的客戶。他們可以是組織或個人。
+Rented From Date,從日期租用
+Enough Parts to Build,足夠的配件組裝
+POS Profile User,POS配置文件用戶
+Row {0}: Depreciation Start Date is required,行{0}：折舊開始日期是必需的
+Service Start Date,服務開始日期
+Subscription Invoice,訂閱發票
+Direct Income,直接收入
+Date TIme,約會時間
+"Can not filter based on Account, if grouped by Account",7 。總計：累積總數達到了這一點。
+Administrative Officer,政務主任
+Setting up company and taxes,建立公司和稅收
+Please select Course,請選擇課程
+Codification Table,編纂表
+Hrs,小時
+Please select Company,請選擇公司
+Difference Account,差異科目
+Supplier GSTIN,供應商GSTIN,
+Cannot close task as its dependant task {0} is not closed.,不能因為其依賴的任務{0}沒有關閉關閉任務。
+Please enter Warehouse for which Material Request will be raised,請輸入物料需求欲增加的倉庫
+Additional Operating Cost,額外的運營成本
+Lab Routine,實驗室常規
+Cosmetics,化妝品
+Please select Completion Date for Completed Asset Maintenance Log,請選擇已完成資產維護日誌的完成日期
+"To merge, following properties must be same for both items",若要合併，以下屬性必須為這兩個項目是相同的
+Block Supplier,塊供應商
+Net Weight,淨重
+Planned number of Positions,計劃的職位數量
+Emergency Phone,緊急電話
+{0} {1} does not exist.,{0} {1} 不存在。
+Buy,購買
+Serial No Warranty Expiry,序列號保修到期
+Offline POS Name,離線POS名稱
+Student Application,學生申請
+Payment Reference,付款憑據
+Hold Type,保持類型
+Please define grade for Threshold 0%,請定義等級為閾值0％
+Please define grade for Threshold 0%,請定義等級為閾值0％
+Bank Statement Transaction Payment Item,銀行對賬單交易付款項目
+To Deliver,為了提供
+Item,項目
+High Sensitivity,高靈敏度
+Volunteer Type information.,志願者類型信息。
+Cash Flow Mapping Template,現金流量映射模板
+Costing Details,成本計算詳情
+Show Return Entries,顯示返回條目
+Serial no item cannot be a fraction,序號項目不能是一個分數
+Difference (Dr - Cr),差異（Dr - Cr）
+Profit and Loss,損益
+"Not permitted, configure Lab Test Template as required",不允許，根據需要配置實驗室測試模板
+Risk Factors,風險因素
+Occupational Hazards and Environmental Factors,職業危害與環境因素
+Stock Entries already created for Work Order ,已為工單創建的庫存條目
+Respiratory rate,呼吸頻率
+Managing Subcontracting,管理轉包
+Body Temperature,體溫
+Project will be accessible on the website to these users,項目將在網站向這些用戶上訪問
+Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},無法取消{0} {1}，因為序列號{2}不屬於倉庫{3}
+Default Deferred Expense Account,默認遞延費用科目
+Define Project type.,定義項目類型。
+Weighting Function,加權函數
+OP Consulting Charge,OP諮詢費
+Setup your ,設置你的
+Show Marks,顯示標記
+Get Latest Query,獲取最新查詢
+Rate at which Price list currency is converted to company's base currency,價目表貨幣被換算成公司基礎貨幣的匯率
+Account {0} does not belong to company: {1},科目{0}不屬於公司：{1}
+Abbreviation already used for another company,另一家公司已使用此縮寫
+Default Customer Group,預設客戶群組
+IFSC Code,IFSC代碼
+"If disable, 'Rounded Total' field will not be visible in any transaction",如果禁用，“圓角總計”字段將不可見的任何交易
+Operating Cost,營業成本
+Produced Items,生產物品
+Match Transaction to Invoices,將交易與發票匹配
+Unblock Invoice,取消屏蔽發票
+Increment cannot be 0,增量不能為0,
+Delete Company Transactions,刪除公司事務
+Reference No and Reference Date is mandatory for Bank transaction,參考編號和參考日期是強制性的銀行交易
+Add / Edit Taxes and Charges,新增 / 編輯稅金及費用
+Supplier Invoice No,供應商發票號碼
+For reference,供參考
+Appointment Confirmation,預約確認
+"Cannot delete Serial No {0}, as it is used in stock transactions",無法刪除序列號{0}，因為它採用的是現貨交易
+Closing (Cr),關閉（Cr）
+Move Item,移動項目
+Incentive Amount,激勵金額
+Warranty Period (Days),保修期限（天數）
+Total Credit/ Debit Amount should be same as linked Journal Entry,總信用/借方金額應與鏈接的日記帳分錄相同
+Installation Note Item,安裝注意項
+Pending Qty,待定數量
+{0} {1} is not active,{0} {1}是不活動
+Freight and Forwarding Account,貨運和轉運科目
+Setup cheque dimensions for printing,設置檢查尺寸打印
+Create Salary Slips,創建工資單
+Bloated,脹
+Salary Slip Timesheet,工資單時間表
+Supplier Warehouse mandatory for sub-contracted Purchase Receipt,對於轉包的採購入庫單，供應商倉庫是強制性輸入的。
+Total Commission,佣金總計
+Tax Withholding Account,扣繳稅款科目
+Sales Partner,銷售合作夥伴
+All Supplier scorecards.,所有供應商記分卡。
+Purchase Receipt Required,需要採購入庫單
+Rail,軌
+Target warehouse in row {0} must be same as Work Order,行{0}中的目標倉庫必須與工單相同
+Valuation Rate is mandatory if Opening Stock entered,估價費用是強制性的，如果打開庫存進入
+No records found in the Invoice table,沒有在發票表中找到記錄
+Please select Company and Party Type first,請選擇公司和黨的第一型
+"Already set default in pos profile {0} for user {1}, kindly disabled default",已經在用戶{1}的pos配置文件{0}中設置了默認值，請禁用默認值
+Financial / accounting year.,財務／會計年度。
+Accumulated Values,累積值
+"Sorry, Serial Nos cannot be merged",對不起，序列號無法合併
+Customer Group will set to selected group while syncing customers from Shopify,客戶組將在同步Shopify客戶的同時設置為選定的組
+Territory is Required in POS Profile,POS Profile中需要領域
+Hub User,中心用戶
+Make Sales Order,製作銷售訂單
+Salary Slip submitted for period from {0} to {1},從{0}到{1}
+Project Task,項目任務
+Redeemed Points,兌換積分
+Lead Id,潛在客戶標識
+Grand Total,累計
+Course,課程
+Section Code,部分代碼
+Payslip,工資單
+Half day date should be in between from date and to date,半天的日期應該在從日期到日期之間
+Item Cart,項目車
+Fiscal Year Start Date should not be greater than Fiscal Year End Date,會計年度開始日期應不大於財政年度結束日期
+Resolution,決議
+Personal Bio,個人自傳
+Membership ID,會員ID,
+Delivered: {0},交貨：{0}
+Connected to QuickBooks,連接到QuickBooks,
+Payable Account,應付帳款
+Type of Payment,付款類型
+Half Day Date is mandatory,半天日期是強制性的
+Billing and Delivery Status,結算和交貨狀態
+Resume Attachment,簡歷附
+Repeat Customers,回頭客
+Create Variant,創建變體
+Shipping Bill Date,運費單日期
+Production Plan,生產計劃
+Opening Invoice Creation Tool,打開發票創建工具
+Sales Return,銷貨退回
+Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,注：總分配葉{0}應不低於已核定葉{1}期間
+Set Qty in Transactions based on Serial No Input,根據序列號輸入設置交易數量
+Total Stock Summary,總庫存總結
+"You can only plan for upto {0} vacancies and budget {1} \
 				for {2} as per staffing plan {3} for parent company {4}.",根據母公司{4}的人員配置計劃{3}，您只能針對{2}計劃最多{0}個職位空缺和預算{1} \。
-DocType: Announcement,Posted By,發布者
-DocType: Item,Delivered by Supplier (Drop Ship),由供應商交貨（直接發運）
-DocType: Healthcare Settings,Confirmation Message,確認訊息
-apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,數據庫的潛在客戶。
-DocType: Authorization Rule,Customer or Item,客戶或項目
-apps/erpnext/erpnext/config/selling.py +28,Customer database.,客戶數據庫。
-DocType: Quotation,Quotation To,報價到
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +250,Opening (Cr),開啟（Cr ）
-apps/erpnext/erpnext/stock/doctype/item/item.py +950,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,測度項目的默認單位{0}不能直接改變，因為你已經做了一些交易（S）與其他計量單位。您將需要創建一個新的項目，以使用不同的默認計量單位。
-apps/erpnext/erpnext/accounts/utils.py +378,Allocated amount can not be negative,分配金額不能為負
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,請設定公司
-DocType: Share Balance,Share Balance,份額平衡
-DocType: Amazon MWS Settings,AWS Access Key ID,AWS訪問密鑰ID
-DocType: Purchase Order Item,Billed Amt,已結算額
-DocType: Training Result Employee,Training Result Employee,訓練結果員工
-DocType: Warehouse,A logical Warehouse against which stock entries are made.,對這些庫存分錄帳進行的邏輯倉庫。
-DocType: Loan Application,Total Payable Interest,合計應付利息
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +58,Total Outstanding: {0},總計：{0}
-DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,銷售發票時間表
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +150,Reference No & Reference Date is required for {0},參考號與參考日期須為{0}
-DocType: Payroll Entry,Select Payment Account to make Bank Entry,選擇付款科目，使銀行進入
-DocType: Hotel Settings,Default Invoice Naming Series,默認發票命名系列
-apps/erpnext/erpnext/utilities/activation.py +136,"Create Employee records to manage leaves, expense claims and payroll",建立員工檔案管理葉，報銷和工資
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +712,An error occurred during the update process,更新過程中發生錯誤
-DocType: Restaurant Reservation,Restaurant Reservation,餐廳預訂
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,Proposal Writing,提案寫作
-DocType: Payment Entry Deduction,Payment Entry Deduction,輸入付款扣除
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15,Wrapping up,包起來
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +45,Notify Customers via Email,通過電子郵件通知客戶
-DocType: Item,Batch Number Series,批號系列
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +54,Another Sales Person {0} exists with the same Employee id,另外銷售人員{0}存在具有相同員工ID
-DocType: Employee Advance,Claimed Amount,聲明金額
-DocType: QuickBooks Migrator,Authorization Settings,授權設置
-DocType: Travel Itinerary,Departure Datetime,離開日期時間
-DocType: Travel Request Costing,Travel Request Costing,旅行請求成本計算
-apps/erpnext/erpnext/config/education.py +180,Masters,資料主檔
-DocType: Employee Onboarding,Employee Onboarding Template,員工入職模板
-DocType: Assessment Plan,Maximum Assessment Score,最大考核評分
-apps/erpnext/erpnext/config/accounts.py +134,Update Bank Transaction Dates,更新銀行交易日期
-apps/erpnext/erpnext/config/projects.py +41,Time Tracking,時間跟踪
-DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,輸送機重複
-apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +57,Row {0}# Paid Amount cannot be greater than requested advance amount,行{0}＃付費金額不能大於請求的提前金額
-DocType: Fiscal Year Company,Fiscal Year Company,會計年度公司
-DocType: Packing Slip Item,DN Detail,DN詳細
-DocType: Training Event,Conference,會議
-DocType: Employee Grade,Default Salary Structure,默認工資結構
-DocType: Timesheet,Billed,計費
-DocType: Batch,Batch Description,批次說明
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,創建學生組
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,創建學生組
-apps/erpnext/erpnext/accounts/utils.py +763,"Payment Gateway Account not created, please create one manually.",支付閘道科目沒有創建，請手動創建一個。
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,按照DOB的規定，沒有資格參加本計劃
-DocType: Sales Invoice,Sales Taxes and Charges,銷售稅金及費用
-DocType: Student,Sibling Details,兄弟姐妹詳情
-DocType: Vehicle Service,Vehicle Service,汽車服務
-apps/erpnext/erpnext/config/setup.py +95,Automatically triggers the feedback request based on conditions.,自動觸發基於條件的反饋請求。
-DocType: Employee,Reason for Resignation,辭退原因
-DocType: Sales Invoice,Credit Note Issued,信用票據發行
-DocType: Payment Reconciliation,Invoice/Journal Entry Details,發票/日記帳分錄詳細資訊
-apps/erpnext/erpnext/accounts/utils.py +84,{0} '{1}' not in Fiscal Year {2},{0}“ {1}”不在財政年度{2}
-DocType: Buying Settings,Settings for Buying Module,設置購買模塊
-apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +22,Asset {0} does not belong to company {1},資產{0}不屬於公司{1}
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70,Please enter Purchase Receipt first,請先輸入採購入庫單
-DocType: Buying Settings,Supplier Naming By,供應商命名
-DocType: Activity Type,Default Costing Rate,默認成本核算率
-DocType: Maintenance Schedule,Maintenance Schedule,維護計劃
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +163,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.",然後定價規則將被過濾掉基於客戶，客戶群組，領地，供應商，供應商類型，活動，銷售合作夥伴等。
-DocType: Employee Promotion,Employee Promotion Details,員工促銷詳情
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +83,Net Change in Inventory,在庫存淨變動
-DocType: Employee,Passport Number,護照號碼
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,與關係Guardian2
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +87,Manager,經理
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +8,From Fiscal Year,從財政年度開始
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +185,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},新的信用額度小於當前餘額為客戶著想。信用額度是ATLEAST {0}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +453,Please set account in Warehouse {0},請在倉庫{0}中設置會計科目
-apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,“根據”和“分組依據”不能相同
-DocType: Sales Person,Sales Person Targets,銷售人員目標
-DocType: Work Order Operation,In minutes,在幾分鐘內
-DocType: Issue,Resolution Date,決議日期
-DocType: Lab Test Template,Compound,複合
-apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py +11,Dispatch Notification,發貨通知
-apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +56,Select Property,選擇屬性
-DocType: Fee Validity,Max number of visit,最大訪問次數
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +339,Timesheet created:,創建時間表：
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1213,Please set default Cash or Bank account in Mode of Payment {0},請設定現金或銀行帳戶的預設付款方式{0}
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24,Enroll,註冊
-DocType: GST Settings,GST Settings,GST設置
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +81,Currency should be same as Price List Currency: {0},貨幣應與價目表貨幣相同：{0}
-DocType: Selling Settings,Customer Naming By,客戶命名由
-DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,將顯示學生每月學生出勤記錄報告為存在
-DocType: Depreciation Schedule,Depreciation Amount,折舊額
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +105,Convert to Group,轉換為集團
-DocType: Activity Cost,Activity Type,活動類型
-DocType: Request for Quotation,For individual supplier,對於個別供應商
-DocType: BOM Operation,Base Hour Rate(Company Currency),基數小時率（公司貨幣）
-apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Delivered Amount,交付金額
-DocType: Loyalty Point Entry Redemption,Redemption Date,贖回日期
-DocType: Quotation Item,Item Balance,項目平衡
-DocType: Sales Invoice,Packing List,包裝清單
-apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,購買給供應商的訂單。
-DocType: Clinical Procedure Item,Transfer Qty,轉移數量
-DocType: Purchase Invoice Item,Asset Location,資產位置
-DocType: Tax Rule,Shipping Zipcode,運輸郵編
-DocType: Accounts Settings,Report Settings,報告設置
-DocType: Activity Cost,Projects User,項目用戶
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,消費
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158,{0}: {1} not found in Invoice Details table,{0}：在發票明細表中找不到{1}
-DocType: Asset,Asset Owner Company,資產所有者公司
-DocType: Company,Round Off Cost Center,四捨五入成本中心
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +257,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,維護訪問{0}必須取消這個銷售訂單之前被取消
-apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js +14,Material Transfer,物料轉倉
-DocType: Cost Center,Cost Center Number,成本中心編號
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24,Could not find path for ,找不到路徑
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +243,Opening (Dr),開啟（Dr）
-DocType: Compensatory Leave Request,Work End Date,工作結束日期
-DocType: Loan,Applicant,申請人
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +37,Posting timestamp must be after {0},登錄時間戳記必須晚於{0}
-apps/erpnext/erpnext/config/accounts.py +293,To make recurring documents,複製文件
-,GST Itemised Purchase Register,GST成品採購登記冊
-DocType: Loan,Total Interest Payable,合計應付利息
-DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,到岸成本稅費
-DocType: Work Order Operation,Actual Start Time,實際開始時間
-DocType: Purchase Invoice Item,Deferred Expense Account,遞延費用科目
-DocType: BOM Operation,Operation Time,操作時間
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +466,Finish,完
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +441,Base,基礎
-DocType: Timesheet,Total Billed Hours,帳單總時間
-DocType: Travel Itinerary,Travel To,前往
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1659,Write Off Amount,核銷金額
-DocType: Leave Block List Allow,Allow User,允許用戶
-DocType: Journal Entry,Bill No,帳單號碼
-DocType: Company,Gain/Loss Account on Asset Disposal,在資產處置收益/損失科目
-DocType: Vehicle Log,Service Details,服務細節
-DocType: Vehicle Log,Service Details,服務細節
-DocType: Lab Test Template,Grouped,分組
-DocType: Selling Settings,Delivery Note Required,要求送貨單
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +537,Submitting Salary Slips...,提交工資單......
-DocType: Bank Guarantee,Bank Guarantee Number,銀行擔保編號
-DocType: Bank Guarantee,Bank Guarantee Number,銀行擔保編號
-DocType: Assessment Criteria,Assessment Criteria,評估標準
-DocType: BOM Item,Basic Rate (Company Currency),基礎匯率（公司貨幣）
-apps/erpnext/erpnext/support/doctype/issue/issue.js +38,Split Issue,拆分問題
-DocType: Student Attendance,Student Attendance,學生出勤
-DocType: Sales Invoice Timesheet,Time Sheet,時間表
-DocType: Manufacturing Settings,Backflush Raw Materials Based On,倒沖原物料基於
-DocType: Sales Invoice,Port Code,港口代碼
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1031,Reserve Warehouse,儲備倉庫
-DocType: Lead,Lead is an Organization,領導是一個組織
-DocType: Instructor Log,Other Details,其他詳細資訊
-apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,Suplier
-DocType: Lab Test,Test Template,測試模板
-apps/erpnext/erpnext/config/non_profit.py +13,Chapter information.,章節信息。
-DocType: Account,Accounts,會計
-DocType: Vehicle,Odometer Value (Last),里程表值（最後）
-apps/erpnext/erpnext/config/buying.py +160,Templates of supplier scorecard criteria.,供應商計分卡標準模板。
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +382,Marketing,市場營銷
-DocType: Sales Invoice,Redeem Loyalty Points,兌換忠誠度積分
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +348,Payment Entry is already created,已創建付款輸入
-DocType: Request for Quotation,Get Suppliers,獲取供應商
-DocType: Purchase Receipt Item Supplied,Current Stock,當前庫存
-apps/erpnext/erpnext/controllers/accounts_controller.py +681,Row #{0}: Asset {1} does not linked to Item {2},行＃{0}：資產{1}不掛項目{2}
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +408,Preview Salary Slip,預覽工資單
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +64,Account {0} has been entered multiple times,帳戶{0}已多次輸入
-DocType: Account,Expenses Included In Valuation,支出計入估值
-apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +38,You can only renew if your membership expires within 30 days,如果您的會員資格在30天內到期，您只能續訂
-DocType: Shopping Cart Settings,Show Stock Availability,顯示庫存可用性
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +519,Set {0} in asset category {1} or company {2},在資產類別{1}或公司{2}中設置{0}
-DocType: Location,Longitude,經度
-,Absent Student Report,缺席學生報告
-DocType: Crop,Crop Spacing UOM,裁剪間隔UOM
-DocType: Loyalty Program,Single Tier Program,單層計劃
-DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,只有在設置了“現金流量映射器”文檔時才能選擇
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +189,From Address 1,來自地址1
-DocType: Email Digest,Next email will be sent on:,接下來的電子郵件將被發送：
-DocType: Supplier Scorecard,Per Week,每個星期
-apps/erpnext/erpnext/stock/doctype/item/item.py +725,Item has variants.,項目已變種。
-apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,學生總數
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,項{0}未找到
-DocType: Bin,Stock Value,庫存價值
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +54,Tree Type,樹類型
-DocType: BOM Explosion Item,Qty Consumed Per Unit,數量消耗每單位
-DocType: GST Account,IGST Account,IGST帳戶
-DocType: Serial No,Warranty Expiry Date,保證期到期日
-DocType: Material Request Item,Quantity and Warehouse,數量和倉庫
-DocType: Sales Invoice,Commission Rate (%),佣金比率（％）
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,請選擇程序
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,請選擇程序
-DocType: Project,Estimated Cost,估計成本
-DocType: Request for Quotation,Link to material requests,鏈接到材料請求
-DocType: Journal Entry,Credit Card Entry,信用卡進入
-apps/erpnext/erpnext/config/accounts.py +35,Company and Accounts,公司與科目
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +85,In Value,在數值
-DocType: Asset Settings,Depreciation Options,折舊選項
-apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28,Either location or employee must be required,必須要求地點或員工
-apps/erpnext/erpnext/utilities/transaction_base.py +29,Invalid Posting Time,發佈時間無效
-DocType: Salary Component,Condition and Formula,條件和公式
-DocType: Lead,Campaign Name,活動名稱
-apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +61,There is no leave period in between {0} and {1},{0}和{1}之間沒有休假期限
-DocType: Fee Validity,Healthcare Practitioner,醫療從業者
-DocType: Travel Request Costing,Expense Type,費用類型
-DocType: Selling Settings,Close Opportunity After Days,關閉機會後日
-DocType: Driver,License Details,許可證詳情
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +86,The field From Shareholder cannot be blank,來自股東的字段不能為空
-DocType: Purchase Order,Supply Raw Materials,供應原料
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,流動資產
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +161,{0} is not a stock Item,{0}不是庫存項目
-apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html +6,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',請通過點擊“培訓反饋”，然後點擊“新建”
-DocType: Mode of Payment Account,Default Account,預設科目
-apps/erpnext/erpnext/stock/doctype/item/item.py +302,Please select Sample Retention Warehouse in Stock Settings first,請先在庫存設置中選擇樣品保留倉庫
-apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +62,Please select the Multiple Tier Program type for more than one collection rules.,請為多個收集規則選擇多層程序類型。
-DocType: Payment Entry,Received Amount (Company Currency),收到的款項（公司幣種）
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,Lead must be set if Opportunity is made from Lead,如果機會是由前導而來，前導必須被設定
-apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +136,Payment Cancelled. Please check your GoCardless Account for more details,付款已取消。請檢查您的GoCardless帳戶以了解更多詳情
-DocType: Delivery Settings,Send with Attachment,發送附件
-apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +30,Please select weekly off day,請選擇每週休息日
-DocType: Inpatient Record,O Negative,O負面
-DocType: Work Order Operation,Planned End Time,計劃結束時間
-,Sales Person Target Variance Item Group-Wise,銷售人員跨項目群組間的目標差異
-apps/erpnext/erpnext/accounts/doctype/account/account.py +100,Account with existing transaction cannot be converted to ledger,帳戶與現有的交易不能被轉換為總賬
-apps/erpnext/erpnext/config/non_profit.py +33,Memebership Type Details,Memebership類型詳細信息
-DocType: Delivery Note,Customer's Purchase Order No,客戶的採購訂單編號
-DocType: Clinical Procedure,Consume Stock,消費庫存
-DocType: Budget,Budget Against,反對財政預算案
-apps/erpnext/erpnext/stock/reorder_item.py +194,Auto Material Requests Generated,汽車材料的要求生成
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,丟失
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +184,You can not enter current voucher in 'Against Journal Entry' column,在您不能輸入電流券“對日記帳分錄”專欄
-DocType: Employee Benefit Application Detail,Max Benefit Amount,最大福利金額
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,預留製造
-DocType: Opportunity,Opportunity From,機會從
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +997,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,行{0}：{1}項目{2}所需的序列號。你已經提供{3}。
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79,Please select a table,請選擇一張桌子
-DocType: BOM,Website Specifications,網站規格
-DocType: Special Test Items,Particulars,細節
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +23,{0}: From {0} of type {1},{0}：從{0}類型{1}
-apps/erpnext/erpnext/controllers/buying_controller.py +399,Row {0}: Conversion Factor is mandatory,列#{0}：轉換係數是強制性的
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +353,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}",海報價格規則，同樣的標準存在，請通過分配優先解決衝突。價格規則：{0}
-DocType: Exchange Rate Revaluation,Exchange Rate Revaluation Account,匯率重估科目
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +539,Cannot deactivate or cancel BOM as it is linked with other BOMs,無法關閉或取消BOM，因為它是與其他材料明細表鏈接
-apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js +106,Please select Company and Posting Date to getting entries,請選擇公司和發布日期以獲取條目
-DocType: Asset,Maintenance,維護
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Get from Patient Encounter,從患者遭遇中獲取
-DocType: Subscriber,Subscriber,訂戶
-DocType: Item Attribute Value,Item Attribute Value,項目屬性值
-apps/erpnext/erpnext/projects/doctype/project/project.py +455,Please Update your Project Status,請更新您的項目狀態
-apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +26,Currency Exchange must be applicable for Buying or for Selling.,貨幣兌換必須適用於買入或賣出。
-DocType: Item,Maximum sample quantity that can be retained,可以保留的最大樣品數量
-DocType: Project Update,How is the Project Progressing Right Now?,項目現在進展如何？
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +505,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},對於採購訂單{3}，行{0}＃項目{1}不能超過{2}
-apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,銷售活動。
-DocType: Project Task,Make Timesheet,製作時間表
-DocType: Sales Taxes and Charges Template,"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
+Posted By,發布者
+Delivered by Supplier (Drop Ship),由供應商交貨（直接發運）
+Confirmation Message,確認訊息
+Database of potential customers.,數據庫的潛在客戶。
+Customer or Item,客戶或項目
+Customer database.,客戶數據庫。
+Quotation To,報價到
+Opening (Cr),開啟（Cr ）
+Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,測度項目的默認單位{0}不能直接改變，因為你已經做了一些交易（S）與其他計量單位。您將需要創建一個新的項目，以使用不同的默認計量單位。
+Allocated amount can not be negative,分配金額不能為負
+Please set the Company,請設定公司
+Share Balance,份額平衡
+AWS Access Key ID,AWS訪問密鑰ID,
+Billed Amt,已結算額
+Training Result Employee,訓練結果員工
+A logical Warehouse against which stock entries are made.,對這些庫存分錄帳進行的邏輯倉庫。
+Total Payable Interest,合計應付利息
+Total Outstanding: {0},總計：{0}
+Sales Invoice Timesheet,銷售發票時間表
+Reference No & Reference Date is required for {0},參考號與參考日期須為{0}
+Select Payment Account to make Bank Entry,選擇付款科目，使銀行進入
+Default Invoice Naming Series,默認發票命名系列
+"Create Employee records to manage leaves, expense claims and payroll",建立員工檔案管理葉，報銷和工資
+An error occurred during the update process,更新過程中發生錯誤
+Restaurant Reservation,餐廳預訂
+Proposal Writing,提案寫作
+Payment Entry Deduction,輸入付款扣除
+Wrapping up,包起來
+Notify Customers via Email,通過電子郵件通知客戶
+Batch Number Series,批號系列
+Another Sales Person {0} exists with the same Employee id,另外銷售人員{0}存在具有相同員工ID,
+Claimed Amount,聲明金額
+Authorization Settings,授權設置
+Departure Datetime,離開日期時間
+Travel Request Costing,旅行請求成本計算
+Masters,資料主檔
+Employee Onboarding Template,員工入職模板
+Maximum Assessment Score,最大考核評分
+Update Bank Transaction Dates,更新銀行交易日期
+Time Tracking,時間跟踪
+DUPLICATE FOR TRANSPORTER,輸送機重複
+Row {0}# Paid Amount cannot be greater than requested advance amount,行{0}＃付費金額不能大於請求的提前金額
+Fiscal Year Company,會計年度公司
+DN Detail,DN詳細
+Conference,會議
+Default Salary Structure,默認工資結構
+Billed,計費
+Batch Description,批次說明
+Creating student groups,創建學生組
+Creating student groups,創建學生組
+"Payment Gateway Account not created, please create one manually.",支付閘道科目沒有創建，請手動創建一個。
+Not eligible for the admission in this program as per DOB,按照DOB的規定，沒有資格參加本計劃
+Sales Taxes and Charges,銷售稅金及費用
+Sibling Details,兄弟姐妹詳情
+Vehicle Service,汽車服務
+Automatically triggers the feedback request based on conditions.,自動觸發基於條件的反饋請求。
+Reason for Resignation,辭退原因
+Credit Note Issued,信用票據發行
+Invoice/Journal Entry Details,發票/日記帳分錄詳細資訊
+{0} '{1}' not in Fiscal Year {2},{0}“ {1}”不在財政年度{2}
+Settings for Buying Module,設置購買模塊
+Asset {0} does not belong to company {1},資產{0}不屬於公司{1}
+Please enter Purchase Receipt first,請先輸入採購入庫單
+Supplier Naming By,供應商命名
+Default Costing Rate,默認成本核算率
+Maintenance Schedule,維護計劃
+"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.",然後定價規則將被過濾掉基於客戶，客戶群組，領地，供應商，供應商類型，活動，銷售合作夥伴等。
+Employee Promotion Details,員工促銷詳情
+Net Change in Inventory,在庫存淨變動
+Passport Number,護照號碼
+Relation with Guardian2,與關係Guardian2,
+Manager,經理
+From Fiscal Year,從財政年度開始
+New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},新的信用額度小於當前餘額為客戶著想。信用額度是ATLEAST {0}
+Please set account in Warehouse {0},請在倉庫{0}中設置會計科目
+'Based On' and 'Group By' can not be same,“根據”和“分組依據”不能相同
+Sales Person Targets,銷售人員目標
+In minutes,在幾分鐘內
+Resolution Date,決議日期
+Compound,複合
+Dispatch Notification,發貨通知
+Select Property,選擇屬性
+Max number of visit,最大訪問次數
+Timesheet created:,創建時間表：
+Please set default Cash or Bank account in Mode of Payment {0},請設定現金或銀行帳戶的預設付款方式{0}
+Enroll,註冊
+GST Settings,GST設置
+Currency should be same as Price List Currency: {0},貨幣應與價目表貨幣相同：{0}
+Customer Naming By,客戶命名由
+Will show the student as Present in Student Monthly Attendance Report,將顯示學生每月學生出勤記錄報告為存在
+Depreciation Amount,折舊額
+Convert to Group,轉換為集團
+Activity Type,活動類型
+For individual supplier,對於個別供應商
+Base Hour Rate(Company Currency),基數小時率（公司貨幣）
+Delivered Amount,交付金額
+Redemption Date,贖回日期
+Item Balance,項目平衡
+Packing List,包裝清單
+Purchase Orders given to Suppliers.,購買給供應商的訂單。
+Transfer Qty,轉移數量
+Asset Location,資產位置
+Shipping Zipcode,運輸郵編
+Report Settings,報告設置
+Projects User,項目用戶
+Consumed,消費
+{0}: {1} not found in Invoice Details table,{0}：在發票明細表中找不到{1}
+Asset Owner Company,資產所有者公司
+Round Off Cost Center,四捨五入成本中心
+Maintenance Visit {0} must be cancelled before cancelling this Sales Order,維護訪問{0}必須取消這個銷售訂單之前被取消
+Material Transfer,物料轉倉
+Cost Center Number,成本中心編號
+Could not find path for ,找不到路徑
+Opening (Dr),開啟（Dr）
+Work End Date,工作結束日期
+Applicant,申請人
+Posting timestamp must be after {0},登錄時間戳記必須晚於{0}
+To make recurring documents,複製文件
+GST Itemised Purchase Register,GST成品採購登記冊
+Total Interest Payable,合計應付利息
+Landed Cost Taxes and Charges,到岸成本稅費
+Actual Start Time,實際開始時間
+Deferred Expense Account,遞延費用科目
+Operation Time,操作時間
+Finish,完
+Base,基礎
+Total Billed Hours,帳單總時間
+Travel To,前往
+Write Off Amount,核銷金額
+Allow User,允許用戶
+Bill No,帳單號碼
+Gain/Loss Account on Asset Disposal,在資產處置收益/損失科目
+Service Details,服務細節
+Service Details,服務細節
+Grouped,分組
+Delivery Note Required,要求送貨單
+Submitting Salary Slips...,提交工資單......
+Bank Guarantee Number,銀行擔保編號
+Bank Guarantee Number,銀行擔保編號
+Assessment Criteria,評估標準
+Basic Rate (Company Currency),基礎匯率（公司貨幣）
+Split Issue,拆分問題
+Student Attendance,學生出勤
+Time Sheet,時間表
+Backflush Raw Materials Based On,倒沖原物料基於
+Port Code,港口代碼
+Reserve Warehouse,儲備倉庫
+Lead is an Organization,領導是一個組織
+Other Details,其他詳細資訊
+Suplier,Suplier,
+Test Template,測試模板
+Chapter information.,章節信息。
+Accounts,會計
+Odometer Value (Last),里程表值（最後）
+Templates of supplier scorecard criteria.,供應商計分卡標準模板。
+Marketing,市場營銷
+Redeem Loyalty Points,兌換忠誠度積分
+Payment Entry is already created,已創建付款輸入
+Get Suppliers,獲取供應商
+Current Stock,當前庫存
+Row #{0}: Asset {1} does not linked to Item {2},行＃{0}：資產{1}不掛項目{2}
+Preview Salary Slip,預覽工資單
+Account {0} has been entered multiple times,帳戶{0}已多次輸入
+Expenses Included In Valuation,支出計入估值
+You can only renew if your membership expires within 30 days,如果您的會員資格在30天內到期，您只能續訂
+Show Stock Availability,顯示庫存可用性
+Set {0} in asset category {1} or company {2},在資產類別{1}或公司{2}中設置{0}
+Longitude,經度
+Absent Student Report,缺席學生報告
+Crop Spacing UOM,裁剪間隔UOM,
+Single Tier Program,單層計劃
+Only select if you have setup Cash Flow Mapper documents,只有在設置了“現金流量映射器”文檔時才能選擇
+From Address 1,來自地址1,
+Next email will be sent on:,接下來的電子郵件將被發送：
+Per Week,每個星期
+Item has variants.,項目已變種。
+Total Student,學生總數
+Item {0} not found,項{0}未找到
+Stock Value,庫存價值
+Tree Type,樹類型
+Qty Consumed Per Unit,數量消耗每單位
+IGST Account,IGST帳戶
+Warranty Expiry Date,保證期到期日
+Quantity and Warehouse,數量和倉庫
+Commission Rate (%),佣金比率（％）
+Please select Program,請選擇程序
+Please select Program,請選擇程序
+Estimated Cost,估計成本
+Link to material requests,鏈接到材料請求
+Credit Card Entry,信用卡進入
+Company and Accounts,公司與科目
+In Value,在數值
+Depreciation Options,折舊選項
+Either location or employee must be required,必須要求地點或員工
+Invalid Posting Time,發佈時間無效
+Condition and Formula,條件和公式
+Campaign Name,活動名稱
+There is no leave period in between {0} and {1},{0}和{1}之間沒有休假期限
+Healthcare Practitioner,醫療從業者
+Expense Type,費用類型
+Close Opportunity After Days,關閉機會後日
+License Details,許可證詳情
+The field From Shareholder cannot be blank,來自股東的字段不能為空
+Supply Raw Materials,供應原料
+Current Assets,流動資產
+{0} is not a stock Item,{0}不是庫存項目
+Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',請通過點擊“培訓反饋”，然後點擊“新建”
+Default Account,預設科目
+Please select Sample Retention Warehouse in Stock Settings first,請先在庫存設置中選擇樣品保留倉庫
+Please select the Multiple Tier Program type for more than one collection rules.,請為多個收集規則選擇多層程序類型。
+Received Amount (Company Currency),收到的款項（公司幣種）
+Lead must be set if Opportunity is made from Lead,如果機會是由前導而來，前導必須被設定
+Payment Cancelled. Please check your GoCardless Account for more details,付款已取消。請檢查您的GoCardless帳戶以了解更多詳情
+Send with Attachment,發送附件
+Please select weekly off day,請選擇每週休息日
+O Negative,O負面
+Planned End Time,計劃結束時間
+Sales Person Target Variance Item Group-Wise,銷售人員跨項目群組間的目標差異
+Account with existing transaction cannot be converted to ledger,帳戶與現有的交易不能被轉換為總賬
+Memebership Type Details,Memebership類型詳細信息
+Customer's Purchase Order No,客戶的採購訂單編號
+Consume Stock,消費庫存
+Budget Against,反對財政預算案
+Auto Material Requests Generated,汽車材料的要求生成
+Lost,丟失
+You can not enter current voucher in 'Against Journal Entry' column,在您不能輸入電流券“對日記帳分錄”專欄
+Max Benefit Amount,最大福利金額
+Reserved for manufacturing,預留製造
+Opportunity From,機會從
+Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,行{0}：{1}項目{2}所需的序列號。你已經提供{3}。
+Please select a table,請選擇一張桌子
+Website Specifications,網站規格
+Particulars,細節
+{0}: From {0} of type {1},{0}：從{0}類型{1}
+Row {0}: Conversion Factor is mandatory,列#{0}：轉換係數是強制性的
+"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}",海報價格規則，同樣的標準存在，請通過分配優先解決衝突。價格規則：{0}
+Exchange Rate Revaluation Account,匯率重估科目
+Cannot deactivate or cancel BOM as it is linked with other BOMs,無法關閉或取消BOM，因為它是與其他材料明細表鏈接
+Please select Company and Posting Date to getting entries,請選擇公司和發布日期以獲取條目
+Maintenance,維護
+Get from Patient Encounter,從患者遭遇中獲取
+Subscriber,訂戶
+Item Attribute Value,項目屬性值
+Please Update your Project Status,請更新您的項目狀態
+Currency Exchange must be applicable for Buying or for Selling.,貨幣兌換必須適用於買入或賣出。
+Maximum sample quantity that can be retained,可以保留的最大樣品數量
+How is the Project Progressing Right Now?,項目現在進展如何？
+Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},對於採購訂單{3}，行{0}＃項目{1}不能超過{2}
+Sales campaigns.,銷售活動。
+Make Timesheet,製作時間表
+"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
 
-#### Note
+#### Note,
 
 The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.
 
-#### Description of Columns
+#### Description of Columns,
 
 1. Calculation Type: 
     - This can be on **Net Total** (that is the sum of basic amount).
     - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
     - **Actual** (as mentioned).
-2. Account Head: The Account ledger under which this tax will be booked
+2. Account Head: The Account ledger under which this tax will be booked,
 3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
 4. Description: Description of the tax (that will be printed in invoices / quotes).
 5. Rate: Tax rate.
@@ -1137,2190 +1137,2190 @@
  7。總計：累積總數達到了這一點。
  8。輸入行：如果基於“前行匯總”，您可以選擇將被視為這種計算基礎（預設值是前行）的行號。
  9。這是含稅的基本速率？：如果你檢查這一點，就意味著這個稅不會顯示在項目表中，但在你的主項表將被納入基本速率。你想要給一個單位的價格（包括所有稅費）的價格為顧客這是非常有用的。"
-DocType: Employee,Bank A/C No.,銀行A/C No.
-DocType: Quality Inspection Reading,Reading 7,7閱讀
-DocType: Lab Test,Lab Test,實驗室測試
-DocType: Student Report Generation Tool,Student Report Generation Tool,學生報告生成工具
-DocType: Healthcare Schedule Time Slot,Healthcare Schedule Time Slot,醫療保健計劃時間槽
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +163,Doc Name,文件名稱
-DocType: Expense Claim Detail,Expense Claim Type,費用報銷型
-DocType: Shopping Cart Settings,Default settings for Shopping Cart,對購物車的預設設定
-apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +27,Add Timeslots,添加時代
-apps/erpnext/erpnext/stock/__init__.py +57,Please set Account in Warehouse {0} or Default Inventory Account in Company {1},請在倉庫{0}中設科目或在公司{1}中設置默認庫存科目
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +143,Asset scrapped via Journal Entry {0},通過資產日記帳分錄報廢{0}
-DocType: Loan,Interest Income Account,利息收入科目
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +61,Max benefits should be greater than zero to dispense benefits,最大的好處應該大於零來分配好處
-apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58,Review Invitation Sent,審核邀請已發送
-DocType: Shift Assignment,Shift Assignment,班次分配
-DocType: Employee Transfer Property,Employee Transfer Property,員工轉移財產
-apps/erpnext/erpnext/accounts/doctype/cashier_closing/cashier_closing.py +36,From Time Should Be Less Than To Time,從時間應該少於時間
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13,Biotechnology,生物技術
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1121,"Item {0} (Serial No: {1}) cannot be consumed as is reserverd\
+Bank A/C No.,銀行A/C No.
+Reading 7,7閱讀
+Lab Test,實驗室測試
+Student Report Generation Tool,學生報告生成工具
+Healthcare Schedule Time Slot,醫療保健計劃時間槽
+Doc Name,文件名稱
+Expense Claim Type,費用報銷型
+Default settings for Shopping Cart,對購物車的預設設定
+Add Timeslots,添加時代
+Please set Account in Warehouse {0} or Default Inventory Account in Company {1},請在倉庫{0}中設科目或在公司{1}中設置默認庫存科目
+Asset scrapped via Journal Entry {0},通過資產日記帳分錄報廢{0}
+Interest Income Account,利息收入科目
+Max benefits should be greater than zero to dispense benefits,最大的好處應該大於零來分配好處
+Review Invitation Sent,審核邀請已發送
+Shift Assignment,班次分配
+Employee Transfer Property,員工轉移財產
+From Time Should Be Less Than To Time,從時間應該少於時間
+Biotechnology,生物技術
+"Item {0} (Serial No: {1}) cannot be consumed as is reserverd\
 						 to fullfill Sales Order {2}.",無法將項目{0}（序列號：{1}）用作reserverd \以完成銷售訂單{2}。
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +116,Office Maintenance Expenses,Office維護費用
-apps/erpnext/erpnext/utilities/user_progress.py +54,Go to ,去
-DocType: Shopify Settings,Update Price from Shopify To ERPNext Price List,將Shopify更新到ERPNext價目表
-apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,設置電子郵件帳戶
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21,Please enter Item first,請先輸入品項
-DocType: Asset Repair,Downtime,停機
-DocType: Account,Liability,責任
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +228,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,制裁金額不能大於索賠額行{0}。
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +14,Academic Term: ,學術期限：
-DocType: Salary Component,Do not include in total,不包括在內
-DocType: Company,Default Cost of Goods Sold Account,銷貨成本科目
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1287,Sample quantity {0} cannot be more than received quantity {1},採樣數量{0}不能超過接收數量{1}
-apps/erpnext/erpnext/stock/get_item_details.py +523,Price List not selected,未選擇價格列表
-DocType: Request for Quotation Supplier,Send Email,發送電子郵件
-apps/erpnext/erpnext/stock/doctype/item/item.py +257,Warning: Invalid Attachment {0},警告：無效的附件{0}
-DocType: Item,Max Sample Quantity,最大樣品量
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +810,No Permission,無權限
-DocType: Contract Fulfilment Checklist,Contract Fulfilment Checklist,合同履行清單
-DocType: Vital Signs,Heart Rate / Pulse,心率/脈搏
-DocType: Company,Default Bank Account,預設銀行會計科目
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +76,"To filter based on Party, select Party Type first",要根據黨的篩選，選擇黨第一類型
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +46,'Update Stock' can not be checked because items are not delivered via {0},不能勾選`更新庫存'，因為項目未交付{0}
-DocType: Vehicle,Acquisition Date,採集日期
-apps/erpnext/erpnext/utilities/user_progress.py +146,Nos,NOS
-DocType: Item,Items with higher weightage will be shown higher,具有較高權重的項目將顯示更高的可
-apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py +12,Lab Tests and Vital Signs,實驗室測試和重要標誌
-DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,銀行對帳詳細
-apps/erpnext/erpnext/controllers/accounts_controller.py +685,Row #{0}: Asset {1} must be submitted,行＃{0}：資產{1}必須提交
-apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,無發現任何員工
-DocType: Item,If subcontracted to a vendor,如果分包給供應商
-apps/erpnext/erpnext/education/doctype/student_group/student_group.js +113,Student Group is already updated.,學生組已經更新。
-apps/erpnext/erpnext/education/doctype/student_group/student_group.js +113,Student Group is already updated.,學生組已經更新。
-apps/erpnext/erpnext/config/projects.py +18,Project Update.,項目更新。
-DocType: SMS Center,All Customer Contact,所有的客戶聯絡
-DocType: Location,Tree Details,樹詳細信息
-DocType: Marketplace Settings,Registered,註冊
-DocType: Training Event,Event Status,事件狀態
-DocType: Volunteer,Availability Timeslot,可用時間段
-,Support Analytics,支援分析
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +410,"If you have any questions, please get back to us.",如果您有任何疑問，請再次與我們聯繫。
-DocType: Cash Flow Mapper,Cash Flow Mapper,現金流量映射器
-DocType: Item,Website Warehouse,網站倉庫
-DocType: Payment Reconciliation,Minimum Invoice Amount,最小發票金額
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +112,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}：成本中心{2}不屬於公司{3}
-apps/erpnext/erpnext/utilities/user_progress.py +92,Upload your letter head (Keep it web friendly as 900px by 100px),上傳你的信頭（保持網頁友好，900px乘100px）
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +89,{0} {1}: Account {2} cannot be a Group,{0} {1}科目{2}不能是一個群組科目
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +367,Timesheet {0} is already completed or cancelled,時間表{0}已完成或取消
-apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,沒有任務
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +81,Sales Invoice {0} created as paid,銷售發票{0}已創建為已付款
-DocType: Item Variant Settings,Copy Fields to Variant,將字段複製到變式
-DocType: Asset,Opening Accumulated Depreciation,打開累計折舊
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +50,Score must be less than or equal to 5,得分必須小於或等於5
-DocType: Program Enrollment Tool,Program Enrollment Tool,計劃註冊工具
-apps/erpnext/erpnext/config/accounts.py +298,C-Form records,C-往績紀錄
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +74,The shares already exist,股份已經存在
-apps/erpnext/erpnext/config/selling.py +322,Customer and Supplier,客戶和供應商
-DocType: Email Digest,Email Digest Settings,電子郵件摘要設定
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +412,Thank you for your business!,感謝您的業務！
-apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,客戶支持查詢。
-DocType: Employee Property History,Employee Property History,員工財產歷史
-DocType: Setup Progress Action,Action Doctype,行動Doctype
-DocType: HR Settings,Retirement Age,退休年齡
-DocType: Bin,Moving Average Rate,移動平均房價
-DocType: Production Plan,Select Items,選擇項目
-DocType: Share Transfer,To Shareholder,給股東
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +408,{0} against Bill {1} dated {2},{0}針對帳單{1}日期{2}
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +213,From State,來自州
-apps/erpnext/erpnext/utilities/user_progress.py +27,Setup Institution,設置機構
-apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +73,Allocating leaves...,分配葉子......
-DocType: Program Enrollment,Vehicle/Bus Number,車輛/巴士號碼
-apps/erpnext/erpnext/education/doctype/course/course.js +17,Course Schedule,課程表
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +570,"You have to Deduct Tax for Unsubmitted Tax Exemption Proof and Unclaimed \
+Office Maintenance Expenses,Office維護費用
+Go to ,去
+Update Price from Shopify To ERPNext Price List,將Shopify更新到ERPNext價目表
+Setting up Email Account,設置電子郵件帳戶
+Please enter Item first,請先輸入品項
+Downtime,停機
+Liability,責任
+Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,制裁金額不能大於索賠額行{0}。
+Academic Term: ,學術期限：
+Do not include in total,不包括在內
+Default Cost of Goods Sold Account,銷貨成本科目
+Sample quantity {0} cannot be more than received quantity {1},採樣數量{0}不能超過接收數量{1}
+Price List not selected,未選擇價格列表
+Send Email,發送電子郵件
+Warning: Invalid Attachment {0},警告：無效的附件{0}
+Max Sample Quantity,最大樣品量
+No Permission,無權限
+Contract Fulfilment Checklist,合同履行清單
+Heart Rate / Pulse,心率/脈搏
+Default Bank Account,預設銀行會計科目
+"To filter based on Party, select Party Type first",要根據黨的篩選，選擇黨第一類型
+'Update Stock' can not be checked because items are not delivered via {0},不能勾選`更新庫存'，因為項目未交付{0}
+Acquisition Date,採集日期
+Nos,NOS,
+Items with higher weightage will be shown higher,具有較高權重的項目將顯示更高的可
+Lab Tests and Vital Signs,實驗室測試和重要標誌
+Bank Reconciliation Detail,銀行對帳詳細
+Row #{0}: Asset {1} must be submitted,行＃{0}：資產{1}必須提交
+No employee found,無發現任何員工
+If subcontracted to a vendor,如果分包給供應商
+Student Group is already updated.,學生組已經更新。
+Student Group is already updated.,學生組已經更新。
+Project Update.,項目更新。
+All Customer Contact,所有的客戶聯絡
+Tree Details,樹詳細信息
+Registered,註冊
+Event Status,事件狀態
+Availability Timeslot,可用時間段
+Support Analytics,支援分析
+"If you have any questions, please get back to us.",如果您有任何疑問，請再次與我們聯繫。
+Cash Flow Mapper,現金流量映射器
+Website Warehouse,網站倉庫
+Minimum Invoice Amount,最小發票金額
+{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}：成本中心{2}不屬於公司{3}
+Upload your letter head (Keep it web friendly as 900px by 100px),上傳你的信頭（保持網頁友好，900px乘100px）
+{0} {1}: Account {2} cannot be a Group,{0} {1}科目{2}不能是一個群組科目
+Timesheet {0} is already completed or cancelled,時間表{0}已完成或取消
+No tasks,沒有任務
+Sales Invoice {0} created as paid,銷售發票{0}已創建為已付款
+Copy Fields to Variant,將字段複製到變式
+Opening Accumulated Depreciation,打開累計折舊
+Score must be less than or equal to 5,得分必須小於或等於5,
+Program Enrollment Tool,計劃註冊工具
+C-Form records,C-往績紀錄
+The shares already exist,股份已經存在
+Customer and Supplier,客戶和供應商
+Email Digest Settings,電子郵件摘要設定
+Thank you for your business!,感謝您的業務！
+Support queries from customers.,客戶支持查詢。
+Employee Property History,員工財產歷史
+Action Doctype,行動Doctype,
+Retirement Age,退休年齡
+Moving Average Rate,移動平均房價
+Select Items,選擇項目
+To Shareholder,給股東
+{0} against Bill {1} dated {2},{0}針對帳單{1}日期{2}
+From State,來自州
+Setup Institution,設置機構
+Allocating leaves...,分配葉子......
+Vehicle/Bus Number,車輛/巴士號碼
+Course Schedule,課程表
+"You have to Deduct Tax for Unsubmitted Tax Exemption Proof and Unclaimed \
 					Employee Benefits in the last Salary Slip of Payroll Period",您必須在工資核算期的最後一個工資單上扣除未提交的免稅證明和無人認領的\員工福利稅
-DocType: Request for Quotation Supplier,Quote Status,報價狀態
-DocType: Maintenance Visit,Completion Status,完成狀態
-DocType: Daily Work Summary Group,Select Users,選擇用戶
-DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,酒店房間定價項目
-DocType: Loyalty Program Collection,Tier Name,等級名稱
-DocType: HR Settings,Enter retirement age in years,在年內進入退休年齡
-DocType: Crop,Target Warehouse,目標倉庫
-DocType: Payroll Employee Detail,Payroll Employee Detail,薪資員工詳細信息
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +135,Please select a warehouse,請選擇一個倉庫
-DocType: Cheque Print Template,Starting location from left edge,從左邊起始位置
-DocType: Item,Allow over delivery or receipt upto this percent,允許在交付或接收高達百分之這
-DocType: Upload Attendance,Import Attendance,進口出席
-apps/erpnext/erpnext/public/js/pos/pos.html +124,All Item Groups,所有項目群組
-DocType: Work Order,Item To Manufacture,產品製造
-apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1}的狀態為{2}
-DocType: Water Analysis,Collection Temperature ,收集溫度
-DocType: Employee,Provide Email Address registered in company,提供公司註冊郵箱地址
-DocType: Shopping Cart Settings,Enable Checkout,啟用結帳
-apps/erpnext/erpnext/config/learn.py +202,Purchase Order to Payment,採購訂單到付款
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,預計數量
-DocType: Drug Prescription,Interval UOM,間隔UOM
-DocType: Customer,"Reselect, if the chosen address is edited after save",重新選擇，如果所選地址在保存後被編輯
-apps/erpnext/erpnext/stock/doctype/item/item.js +607,Item Variant {0} already exists with same attributes,項目變種{0}已經具有相同屬性的存在
-DocType: Item,Hub Publishing Details,Hub發布細節
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +153,'Opening',“開放”
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,開做
-DocType: Issue,Via Customer Portal,通過客戶門戶
-DocType: Notification Control,Delivery Note Message,送貨單留言
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +322,SGST Amount,SGST金額
-DocType: Lab Test Template,Result Format,結果格式
-DocType: Expense Claim,Expenses,開支
-DocType: Item Variant Attribute,Item Variant Attribute,產品規格屬性
-,Purchase Receipt Trends,採購入庫趨勢
-DocType: Vehicle Service,Brake Pad,剎車片
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +392,Research & Development,研究與發展
-apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,帳單數額
-DocType: Company,Registration Details,註冊細節
-DocType: Timesheet,Total Billed Amount,總開單金額
-DocType: Item Reorder,Re-Order Qty,重新排序數量
-DocType: Leave Block List Date,Leave Block List Date,休假區塊清單日期表
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +101,BOM #{0}: Raw material cannot be same as main Item,物料清單＃{0}：原始材料與主要項目不能相同
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +92,Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,在外購入庫單項目表總的相關費用必須是相同的總稅費
-DocType: Sales Team,Incentives,獎勵
-DocType: SMS Log,Requested Numbers,請求號碼
-DocType: Volunteer,Evening,晚間
-DocType: Customer,Bypass credit limit check at Sales Order,在銷售訂單旁邊繞過信貸限額檢查
-apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +106,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart",作為啟用的購物車已啟用“使用購物車”，而應該有購物車至少有一個稅務規則
-DocType: Sales Invoice Item,Stock Details,庫存詳細訊息
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,專案值
-apps/erpnext/erpnext/config/selling.py +332,Point-of-Sale,銷售點
-DocType: Fee Schedule,Fee Creation Status,費用創建狀態
-DocType: Vehicle Log,Odometer Reading,里程表讀數
-apps/erpnext/erpnext/accounts/doctype/account/account.py +123,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'",科目餘額已歸為貸方，不允許設為借方
-DocType: Account,Balance must be,餘額必須
-DocType: Notification Control,Expense Claim Rejected Message,報銷回絕訊息
-,Available Qty,可用數量
-DocType: Shopify Settings,Default Warehouse to to create Sales Order and Delivery Note,默認倉庫到創建銷售訂單和交貨單
-DocType: Purchase Taxes and Charges,On Previous Row Total,在上一行共
-DocType: Purchase Invoice Item,Rejected Qty,被拒絕的數量
-DocType: Setup Progress Action,Action Field,行動領域
-DocType: Healthcare Settings,Manage Customer,管理客戶
-DocType: Amazon MWS Settings,Always synch your products from Amazon MWS before synching the Orders details,在同步訂單詳細信息之前，始終從亞馬遜MWS同步您的產品
-DocType: Delivery Trip,Delivery Stops,交貨停止
-apps/erpnext/erpnext/accounts/deferred_revenue.py +33,Cannot change Service Stop Date for item in row {0},無法更改行{0}中項目的服務停止日期
-DocType: Serial No,Incoming Rate,傳入速率
-DocType: Leave Type,Encashment Threshold Days,封存閾值天數
-,Final Assessment Grades,最終評估等級
-apps/erpnext/erpnext/public/js/setup_wizard.js +110,The name of your company for which you are setting up this system.,您的公司要為其設立這個系統的名稱。
-DocType: HR Settings,Include holidays in Total no. of Working Days,包括節假日的總數。工作日
-apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +107,Setup your Institute in ERPNext,在ERPNext中設置您的研究所
-DocType: Job Applicant,Hold,持有
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +101,Alternate Item,替代項目
-DocType: Project Update,Progress Details,進度細節
-DocType: Shopify Log,Request Data,請求數據
-DocType: Employee,Date of Joining,加入日期
-DocType: Supplier Quotation,Is Subcontracted,轉包
-DocType: Item Attribute,Item Attribute Values,項目屬性值
-DocType: Examination Result,Examination Result,考試成績
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +928,Purchase Receipt,採購入庫單
-,Received Items To Be Billed,待付款的收受品項
-apps/erpnext/erpnext/config/accounts.py +271,Currency exchange rate master.,貨幣匯率的主人。
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +210,Reference Doctype must be one of {0},參考文檔類型必須是一個{0}
-apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js +46,Filter Total Zero Qty,過濾器總計零數量
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +322,Unable to find Time Slot in the next {0} days for Operation {1},找不到時隙在未來{0}天操作{1}
-DocType: Work Order,Plan material for sub-assemblies,計劃材料為子組件
-apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,銷售合作夥伴和地區
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +628,BOM {0} must be active,BOM {0}必須是積極的
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +430,No Items available for transfer,沒有可用於傳輸的項目
-DocType: Employee Boarding Activity,Activity Name,活動名稱
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +867,Change Release Date,更改發布日期
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +218,Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,成品數量<b>{0}</b>和數量<b>{1}</b>不能不同
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +256,Closing (Opening + Total),閉幕（開幕+總計）
-DocType: Delivery Settings,Dispatch Notification Attachment,發貨通知附件
-DocType: Payroll Entry,Number Of Employees,在職員工人數
-DocType: Journal Entry,Depreciation Entry,折舊分錄
-apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py +31,Please select the document type first,請先選擇文檔類型
-apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,取消取消此保養訪問之前，材質訪問{0}
-DocType: Pricing Rule,Rate or Discount,價格或折扣
-DocType: Vital Signs,One Sided,單面
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +218,Serial No {0} does not belong to Item {1},序列號{0}不屬於項目{1}
-DocType: Purchase Receipt Item Supplied,Required Qty,所需數量
-DocType: Marketplace Settings,Custom Data,自定義數據
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +127,Warehouses with existing transaction can not be converted to ledger.,與現有的交易倉庫不能轉換到總帳。
-apps/erpnext/erpnext/controllers/buying_controller.py +582,Serial no is mandatory for the item {0},序列號對於項目{0}是強制性的
-DocType: Bank Reconciliation,Total Amount,總金額
-apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py +24,From Date and To Date lie in different Fiscal Year,從日期和到期日位於不同的財政年度
-apps/erpnext/erpnext/healthcare/utils.py +160,The Patient {0} do not have customer refrence to invoice,患者{0}沒有客戶參考發票
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32,Internet Publishing,互聯網出版
-DocType: Prescription Duration,Number,數
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25,Creating {0} Invoice,創建{0}發票
-DocType: Medical Code,Medical Code Standard,醫療代碼標準
-DocType: Item Group,Item Group Defaults,項目組默認值
-apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +102,Please save before assigning task.,在分配任務之前請保存。
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +89,Balance Value,餘額
-DocType: Lab Test,Lab Technician,實驗室技術員
-apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +40,Sales Price List,銷售價格表
-DocType: Healthcare Settings,"If checked, a customer will be created, mapped to Patient.
+Quote Status,報價狀態
+Completion Status,完成狀態
+Select Users,選擇用戶
+Hotel Room Pricing Item,酒店房間定價項目
+Tier Name,等級名稱
+Enter retirement age in years,在年內進入退休年齡
+Target Warehouse,目標倉庫
+Payroll Employee Detail,薪資員工詳細信息
+Please select a warehouse,請選擇一個倉庫
+Starting location from left edge,從左邊起始位置
+Allow over delivery or receipt upto this percent,允許在交付或接收高達百分之這
+Import Attendance,進口出席
+All Item Groups,所有項目群組
+Item To Manufacture,產品製造
+{0} {1} status is {2},{0} {1}的狀態為{2}
+Collection Temperature ,收集溫度
+Provide Email Address registered in company,提供公司註冊郵箱地址
+Enable Checkout,啟用結帳
+Purchase Order to Payment,採購訂單到付款
+Projected Qty,預計數量
+Interval UOM,間隔UOM,
+"Reselect, if the chosen address is edited after save",重新選擇，如果所選地址在保存後被編輯
+Item Variant {0} already exists with same attributes,項目變種{0}已經具有相同屬性的存在
+Hub Publishing Details,Hub發布細節
+'Opening',“開放”
+Open To Do,開做
+Via Customer Portal,通過客戶門戶
+Delivery Note Message,送貨單留言
+SGST Amount,SGST金額
+Result Format,結果格式
+Expenses,開支
+Item Variant Attribute,產品規格屬性
+Purchase Receipt Trends,採購入庫趨勢
+Brake Pad,剎車片
+Research & Development,研究與發展
+Amount to Bill,帳單數額
+Registration Details,註冊細節
+Total Billed Amount,總開單金額
+Re-Order Qty,重新排序數量
+Leave Block List Date,休假區塊清單日期表
+BOM #{0}: Raw material cannot be same as main Item,物料清單＃{0}：原始材料與主要項目不能相同
+Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,在外購入庫單項目表總的相關費用必須是相同的總稅費
+Incentives,獎勵
+Requested Numbers,請求號碼
+Evening,晚間
+Bypass credit limit check at Sales Order,在銷售訂單旁邊繞過信貸限額檢查
+"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart",作為啟用的購物車已啟用“使用購物車”，而應該有購物車至少有一個稅務規則
+Stock Details,庫存詳細訊息
+Project Value,專案值
+Point-of-Sale,銷售點
+Fee Creation Status,費用創建狀態
+Odometer Reading,里程表讀數
+"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'",科目餘額已歸為貸方，不允許設為借方
+Balance must be,餘額必須
+Expense Claim Rejected Message,報銷回絕訊息
+Available Qty,可用數量
+Default Warehouse to to create Sales Order and Delivery Note,默認倉庫到創建銷售訂單和交貨單
+On Previous Row Total,在上一行共
+Rejected Qty,被拒絕的數量
+Action Field,行動領域
+Manage Customer,管理客戶
+Always synch your products from Amazon MWS before synching the Orders details,在同步訂單詳細信息之前，始終從亞馬遜MWS同步您的產品
+Delivery Stops,交貨停止
+Cannot change Service Stop Date for item in row {0},無法更改行{0}中項目的服務停止日期
+Incoming Rate,傳入速率
+Encashment Threshold Days,封存閾值天數
+Final Assessment Grades,最終評估等級
+The name of your company for which you are setting up this system.,您的公司要為其設立這個系統的名稱。
+Include holidays in Total no. of Working Days,包括節假日的總數。工作日
+Setup your Institute in ERPNext,在ERPNext中設置您的研究所
+Hold,持有
+Alternate Item,替代項目
+Progress Details,進度細節
+Request Data,請求數據
+Date of Joining,加入日期
+Is Subcontracted,轉包
+Item Attribute Values,項目屬性值
+Examination Result,考試成績
+Purchase Receipt,採購入庫單
+Received Items To Be Billed,待付款的收受品項
+Currency exchange rate master.,貨幣匯率的主人。
+Reference Doctype must be one of {0},參考文檔類型必須是一個{0}
+Filter Total Zero Qty,過濾器總計零數量
+Unable to find Time Slot in the next {0} days for Operation {1},找不到時隙在未來{0}天操作{1}
+Plan material for sub-assemblies,計劃材料為子組件
+Sales Partners and Territory,銷售合作夥伴和地區
+BOM {0} must be active,BOM {0}必須是積極的
+No Items available for transfer,沒有可用於傳輸的項目
+Activity Name,活動名稱
+Change Release Date,更改發布日期
+Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,成品數量<b>{0}</b>和數量<b>{1}</b>不能不同
+Closing (Opening + Total),閉幕（開幕+總計）
+Dispatch Notification Attachment,發貨通知附件
+Number Of Employees,在職員工人數
+Depreciation Entry,折舊分錄
+Please select the document type first,請先選擇文檔類型
+Cancel Material Visits {0} before cancelling this Maintenance Visit,取消取消此保養訪問之前，材質訪問{0}
+Rate or Discount,價格或折扣
+One Sided,單面
+Serial No {0} does not belong to Item {1},序列號{0}不屬於項目{1}
+Required Qty,所需數量
+Custom Data,自定義數據
+Warehouses with existing transaction can not be converted to ledger.,與現有的交易倉庫不能轉換到總帳。
+Serial no is mandatory for the item {0},序列號對於項目{0}是強制性的
+Total Amount,總金額
+From Date and To Date lie in different Fiscal Year,從日期和到期日位於不同的財政年度
+The Patient {0} do not have customer refrence to invoice,患者{0}沒有客戶參考發票
+Internet Publishing,互聯網出版
+Number,數
+Creating {0} Invoice,創建{0}發票
+Medical Code Standard,醫療代碼標準
+Item Group Defaults,項目組默認值
+Please save before assigning task.,在分配任務之前請保存。
+Balance Value,餘額
+Lab Technician,實驗室技術員
+Sales Price List,銷售價格表
+"If checked, a customer will be created, mapped to Patient.
 Patient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.",如果選中，將創建一個客戶，映射到患者。將針對該客戶創建病人發票。您也可以在創建患者時選擇現有客戶。
-apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py +63,Customer isn't enrolled in any Loyalty Program,客戶未加入任何忠誠度計劃
-DocType: Bank Reconciliation,Account Currency,科目幣種
-DocType: Lab Test,Sample ID,樣品編號
-apps/erpnext/erpnext/accounts/general_ledger.py +178,Please mention Round Off Account in Company,請註明舍入科目的公司
-DocType: Purchase Receipt,Range,範圍
-DocType: Supplier,Default Payable Accounts,預設應付帳款
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +52,Employee {0} is not active or does not exist,員工{0}不活躍或不存在
-DocType: Fee Structure,Components,組件
-DocType: Support Search Source,Search Term Param Name,搜索字詞Param Name
-DocType: Item Barcode,Item Barcode,商品條碼
-DocType: Woocommerce Settings,Endpoints,端點
-apps/erpnext/erpnext/stock/doctype/item/item.py +720,Item Variants {0} updated,項目變種{0}更新
-DocType: Quality Inspection Reading,Reading 6,6閱讀
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +994,Cannot {0} {1} {2} without any negative outstanding invoice,無法{0} {1} {2}沒有任何負面的優秀發票
-DocType: Share Transfer,From Folio No,來自Folio No
-DocType: Purchase Invoice Advance,Purchase Invoice Advance,購買發票提前
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +231,Row {0}: Credit entry can not be linked with a {1},行{0}：信用記錄無法被鏈接的{1}
-apps/erpnext/erpnext/config/accounts.py +214,Define budget for a financial year.,定義預算財政年度。
-DocType: Shopify Tax Account,ERPNext Account,ERPNext帳戶
-apps/erpnext/erpnext/controllers/accounts_controller.py +58,{0} is blocked so this transaction cannot proceed,{0}被阻止，所以此事務無法繼續
-DocType: Budget,Action if Accumulated Monthly Budget Exceeded on MR,如果累計每月預算超過MR，則採取行動
-DocType: Work Order Operation,Operation completed for how many finished goods?,操作完成多少成品？
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +130,Healthcare Practitioner {0} not available on {1},{1}上沒有醫療從業者{0}
-DocType: Payment Terms Template,Payment Terms Template,付款條款模板
-apps/erpnext/erpnext/public/js/setup_wizard.js +51,The Brand,品牌
-DocType: Manufacturing Settings,Allow Multiple Material Consumption,允許多種材料消耗
-DocType: Employee,Exit Interview Details,退出面試細節
-DocType: Item,Is Purchase Item,是購買項目
-DocType: Bank Statement Transaction Invoice Item,Purchase Invoice,採購發票
-DocType: Manufacturing Settings,Allow multiple Material Consumption against a Work Order,針對工作單允許多種材料消耗
-DocType: GL Entry,Voucher Detail No,券詳細說明暫無
-apps/erpnext/erpnext/accounts/page/pos/pos.js +796,New Sales Invoice,新的銷售發票
-DocType: Stock Entry,Total Outgoing Value,出貨總計值
-DocType: Healthcare Practitioner,Appointments,約會
-apps/erpnext/erpnext/public/js/account_tree_grid.js +223,Opening Date and Closing Date should be within same Fiscal Year,開幕日期和截止日期應在同一會計年度
-DocType: Lead,Request for Information,索取資料
-,LeaderBoard,排行榜
-DocType: Sales Invoice Item,Rate With Margin (Company Currency),利率保證金（公司貨幣）
-apps/erpnext/erpnext/accounts/page/pos/pos.js +809,Sync Offline Invoices,同步離線發票
-DocType: Payment Request,Paid,付費
-DocType: Program Fee,Program Fee,課程費用
-DocType: BOM Update Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.
+Customer isn't enrolled in any Loyalty Program,客戶未加入任何忠誠度計劃
+Account Currency,科目幣種
+Sample ID,樣品編號
+Please mention Round Off Account in Company,請註明舍入科目的公司
+Range,範圍
+Default Payable Accounts,預設應付帳款
+Employee {0} is not active or does not exist,員工{0}不活躍或不存在
+Components,組件
+Search Term Param Name,搜索字詞Param Name,
+Item Barcode,商品條碼
+Endpoints,端點
+Item Variants {0} updated,項目變種{0}更新
+Reading 6,6閱讀
+Cannot {0} {1} {2} without any negative outstanding invoice,無法{0} {1} {2}沒有任何負面的優秀發票
+From Folio No,來自Folio No,
+Purchase Invoice Advance,購買發票提前
+Row {0}: Credit entry can not be linked with a {1},行{0}：信用記錄無法被鏈接的{1}
+Define budget for a financial year.,定義預算財政年度。
+ERPNext Account,ERPNext帳戶
+{0} is blocked so this transaction cannot proceed,{0}被阻止，所以此事務無法繼續
+Action if Accumulated Monthly Budget Exceeded on MR,如果累計每月預算超過MR，則採取行動
+Operation completed for how many finished goods?,操作完成多少成品？
+Healthcare Practitioner {0} not available on {1},{1}上沒有醫療從業者{0}
+Payment Terms Template,付款條款模板
+The Brand,品牌
+Allow Multiple Material Consumption,允許多種材料消耗
+Exit Interview Details,退出面試細節
+Is Purchase Item,是購買項目
+Purchase Invoice,採購發票
+Allow multiple Material Consumption against a Work Order,針對工作單允許多種材料消耗
+Voucher Detail No,券詳細說明暫無
+New Sales Invoice,新的銷售發票
+Total Outgoing Value,出貨總計值
+Appointments,約會
+Opening Date and Closing Date should be within same Fiscal Year,開幕日期和截止日期應在同一會計年度
+Request for Information,索取資料
+LeaderBoard,排行榜
+Rate With Margin (Company Currency),利率保證金（公司貨幣）
+Sync Offline Invoices,同步離線發票
+Paid,付費
+Program Fee,課程費用
+"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.
 It also updates latest price in all the BOMs.",替換使用所有其他BOM的特定BOM。它將替換舊的BOM鏈接，更新成本，並按照新的BOM重新生成“BOM爆炸項目”表。它還更新了所有BOM中的最新價格。
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +483,The following Work Orders were created:,以下工作訂單已創建：
-DocType: Salary Slip,Total in words,總計大寫
-DocType: Inpatient Record,Discharged,出院
-DocType: Material Request Item,Lead Time Date,交貨時間日期
-,Employee Advance Summary,員工提前總結
-DocType: Guardian,Guardian Name,監護人姓名
-DocType: Cheque Print Template,Has Print Format,擁有打印格式
-DocType: Support Settings,Get Started Sections,入門部分
-DocType: Loan,Sanctioned,制裁
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +8,Total Contribution Amount: {0},總貢獻金額：{0}
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +179,Row #{0}: Please specify Serial No for Item {1},列#{0}：請為項目{1}指定序號
-DocType: Payroll Entry,Salary Slips Submitted,提交工資單
-DocType: Crop Cycle,Crop Cycle,作物週期
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +678,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.",對於“產品包”的物品，倉庫，序列號和批號將被從“裝箱單”表考慮。如果倉庫和批次號是相同的任何“產品包”項目的所有包裝物品，這些值可以在主項表中輸入，值將被複製到“裝箱單”表。
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +201,From Place,從地方
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +460,Net Pay cannnot be negative,淨薪酬不能為負
-DocType: Student Admission,Publish on website,發布在網站上
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +778,Supplier Invoice Date cannot be greater than Posting Date,供應商發票的日期不能超過過帳日期更大
-DocType: Purchase Invoice Item,Purchase Order Item,採購訂單項目
-DocType: Agriculture Task,Agriculture Task,農業任務
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +139,Indirect Income,間接收入
-DocType: Student Attendance Tool,Student Attendance Tool,學生考勤工具
-DocType: Restaurant Menu,Price List (Auto created),價目表（自動創建）
-DocType: Cheque Print Template,Date Settings,日期設定
-DocType: Employee Promotion,Employee Promotion Detail,員工促銷細節
-,Company Name,公司名稱
-DocType: SMS Center,Total Message(s),訊息總和（s ）
-DocType: Share Balance,Purchased,購買
-DocType: Item Variant Settings,Rename Attribute Value in Item Attribute.,在項目屬性中重命名屬性值。
-DocType: Purchase Invoice,Additional Discount Percentage,額外折扣百分比
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,查看所有幫助影片名單
-DocType: Agriculture Analysis Criteria,Soil Texture,土壤紋理
-DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,選取支票存入該銀行帳戶的頭。
-DocType: Selling Settings,Allow user to edit Price List Rate in transactions,允許用戶編輯價目表率的交易
-DocType: Pricing Rule,Max Qty,最大數量
-apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js +25,Print Report Card,打印報告卡
-apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30,"Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \
+The following Work Orders were created:,以下工作訂單已創建：
+Total in words,總計大寫
+Discharged,出院
+Lead Time Date,交貨時間日期
+Employee Advance Summary,員工提前總結
+Guardian Name,監護人姓名
+Has Print Format,擁有打印格式
+Get Started Sections,入門部分
+Sanctioned,制裁
+Total Contribution Amount: {0},總貢獻金額：{0}
+Row #{0}: Please specify Serial No for Item {1},列#{0}：請為項目{1}指定序號
+Salary Slips Submitted,提交工資單
+Crop Cycle,作物週期
+"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.",對於“產品包”的物品，倉庫，序列號和批號將被從“裝箱單”表考慮。如果倉庫和批次號是相同的任何“產品包”項目的所有包裝物品，這些值可以在主項表中輸入，值將被複製到“裝箱單”表。
+From Place,從地方
+Net Pay cannnot be negative,淨薪酬不能為負
+Publish on website,發布在網站上
+Supplier Invoice Date cannot be greater than Posting Date,供應商發票的日期不能超過過帳日期更大
+Purchase Order Item,採購訂單項目
+Agriculture Task,農業任務
+Indirect Income,間接收入
+Student Attendance Tool,學生考勤工具
+Price List (Auto created),價目表（自動創建）
+Date Settings,日期設定
+Employee Promotion Detail,員工促銷細節
+Company Name,公司名稱
+Total Message(s),訊息總和（s ）
+Purchased,購買
+Rename Attribute Value in Item Attribute.,在項目屬性中重命名屬性值。
+Additional Discount Percentage,額外折扣百分比
+View a list of all the help videos,查看所有幫助影片名單
+Soil Texture,土壤紋理
+Select account head of the bank where cheque was deposited.,選取支票存入該銀行帳戶的頭。
+Allow user to edit Price List Rate in transactions,允許用戶編輯價目表率的交易
+Max Qty,最大數量
+Print Report Card,打印報告卡
+"Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \
 						Please enter a valid Invoice",行{0}：發票{1}是無效的，它可能會被取消/不存在。 \請輸入有效的發票
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +164,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,行{0}：付款方式對銷售/採購訂單應始終被標記為提前
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16,Chemical,化學藥品
-DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,默認銀行/現金帳戶時，會選擇此模式可以自動在工資日記條目更新。
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96,Total leaves allocated is mandatory for Leave Type {0},為假期類型{0}分配的總分配數是強制性的
-DocType: BOM,Raw Material Cost(Company Currency),原料成本（公司貨幣）
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +86,Row # {0}: Rate cannot be greater than the rate used in {1} {2},行＃{0}：速率不能大於{1} {2}中使用的速率
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +86,Row # {0}: Rate cannot be greater than the rate used in {1} {2},行＃{0}：速率不能大於{1} {2}中使用的速率
-apps/erpnext/erpnext/utilities/user_progress.py +147,Meter,儀表
-DocType: Workstation,Electricity Cost,電力成本
-apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py +15,Amount should be greater than zero.,金額應該大於零。
-apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +23,Lab testing datetime cannot be before collection datetime,實驗室測試日期時間不能在收集日期時間之前
-DocType: HR Settings,Don't send Employee Birthday Reminders,不要送員工生日提醒
-DocType: Expense Claim,Total Advance Amount,總預付金額
-DocType: Delivery Stop,Estimated Arrival,預計抵達時間
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +165,Walk In,走在
-DocType: Item,Inspection Criteria,檢驗標準
-apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,轉移
-DocType: BOM Website Item,BOM Website Item,BOM網站項目
-apps/erpnext/erpnext/public/js/setup_wizard.js +52,Upload your letter head and logo. (you can edit them later).,上傳你的信頭和標誌。 （您可以在以後對其進行編輯）。
-DocType: Timesheet Detail,Bill,法案
-DocType: SMS Center,All Lead (Open),所有鉛（開放）
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +352,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),行{0}：數量不適用於{4}在倉庫{1}在發布條目的時間（{2} {3}）
-apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18,You can only select a maximum of one option from the list of check boxes.,您只能從復選框列表中選擇最多一個選項。
-DocType: Purchase Invoice,Get Advances Paid,獲取有償進展
-DocType: Item,Automatically Create New Batch,自動創建新批
-DocType: Item,Automatically Create New Batch,自動創建新批
-DocType: Student Admission,Admission Start Date,入學開始日期
-DocType: Journal Entry,Total Amount in Words,總金額大寫
-apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29,New Employee,新員工
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7,There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,有一個錯誤。一個可能的原因可能是因為您沒有保存的形式。請聯繫support@erpnext.com如果問題仍然存在。
-apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,我的購物車
-apps/erpnext/erpnext/controllers/selling_controller.py +142,Order Type must be one of {0},訂單類型必須是一個{0}
-DocType: Lead,Next Contact Date,下次聯絡日期
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Opening Qty,開放數量
-DocType: Healthcare Settings,Appointment Reminder,預約提醒
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +550,Please enter Account for Change Amount,對於漲跌額請輸入帳號
-DocType: Program Enrollment Tool Student,Student Batch Name,學生批名
-DocType: Holiday List,Holiday List Name,假日列表名稱
-DocType: Repayment Schedule,Balance Loan Amount,平衡貸款額
-apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +132,Added to details,添加到細節
-apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,課程時間表
-DocType: Budget,Applicable on Material Request,適用於材料請求
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +194,Stock Options,庫存期權
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +628,No Items added to cart,沒有項目已添加到購物車
-DocType: Journal Entry Account,Expense Claim,報銷
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +352,Do you really want to restore this scrapped asset?,難道你真的想恢復這個報廢的資產？
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +530,Qty for {0},數量為{0}
-DocType: Leave Application,Leave Application,休假申請
-DocType: Patient,Patient Relation,患者關係
-DocType: Item,Hub Category to Publish,集線器類別發布
-DocType: Leave Block List,Leave Block List Dates,休假區塊清單日期表
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +297,"Sales Order {0} has reservation for item {1}, you can
-		only deliver reserved {1} against {0}. Serial No {2} cannot
+Row {0}: Payment against Sales/Purchase Order should always be marked as advance,行{0}：付款方式對銷售/採購訂單應始終被標記為提前
+Chemical,化學藥品
+Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,默認銀行/現金帳戶時，會選擇此模式可以自動在工資日記條目更新。
+Total leaves allocated is mandatory for Leave Type {0},為假期類型{0}分配的總分配數是強制性的
+Raw Material Cost(Company Currency),原料成本（公司貨幣）
+Row # {0}: Rate cannot be greater than the rate used in {1} {2},行＃{0}：速率不能大於{1} {2}中使用的速率
+Row # {0}: Rate cannot be greater than the rate used in {1} {2},行＃{0}：速率不能大於{1} {2}中使用的速率
+Meter,儀表
+Electricity Cost,電力成本
+Amount should be greater than zero.,金額應該大於零。
+Lab testing datetime cannot be before collection datetime,實驗室測試日期時間不能在收集日期時間之前
+Don't send Employee Birthday Reminders,不要送員工生日提醒
+Total Advance Amount,總預付金額
+Estimated Arrival,預計抵達時間
+Walk In,走在
+Inspection Criteria,檢驗標準
+Transfered,轉移
+BOM Website Item,BOM網站項目
+Upload your letter head and logo. (you can edit them later).,上傳你的信頭和標誌。 （您可以在以後對其進行編輯）。
+Bill,法案
+All Lead (Open),所有鉛（開放）
+Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),行{0}：數量不適用於{4}在倉庫{1}在發布條目的時間（{2} {3}）
+You can only select a maximum of one option from the list of check boxes.,您只能從復選框列表中選擇最多一個選項。
+Get Advances Paid,獲取有償進展
+Automatically Create New Batch,自動創建新批
+Automatically Create New Batch,自動創建新批
+Admission Start Date,入學開始日期
+Total Amount in Words,總金額大寫
+New Employee,新員工
+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.,有一個錯誤。一個可能的原因可能是因為您沒有保存的形式。請聯繫support@erpnext.com如果問題仍然存在。
+My Cart,我的購物車
+Order Type must be one of {0},訂單類型必須是一個{0}
+Next Contact Date,下次聯絡日期
+Opening Qty,開放數量
+Appointment Reminder,預約提醒
+Please enter Account for Change Amount,對於漲跌額請輸入帳號
+Student Batch Name,學生批名
+Holiday List Name,假日列表名稱
+Balance Loan Amount,平衡貸款額
+Added to details,添加到細節
+Schedule Course,課程時間表
+Applicable on Material Request,適用於材料請求
+Stock Options,庫存期權
+No Items added to cart,沒有項目已添加到購物車
+Expense Claim,報銷
+Do you really want to restore this scrapped asset?,難道你真的想恢復這個報廢的資產？
+Qty for {0},數量為{0}
+Leave Application,休假申請
+Patient Relation,患者關係
+Hub Category to Publish,集線器類別發布
+Leave Block List Dates,休假區塊清單日期表
+"Sales Order {0} has reservation for item {1}, you can,
+		only deliver reserved {1} against {0}. Serial No {2} cannot,
 		be delivered",銷售訂單{0}對項目{1}有預留，您只能對{0}提供保留的{1}。序列號{2}無法發送
-DocType: Sales Invoice,Billing Address GSTIN,帳單地址GSTIN
-DocType: Employee Tax Exemption Proof Submission,Total Eligible HRA Exemption,合格的HRA豁免總數
-DocType: Assessment Plan,Evaluate,評估
-DocType: Workstation,Net Hour Rate,淨小時率
-DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,到岸成本採購入庫單
-DocType: Company,Default Terms,默認條款
-DocType: Supplier Scorecard Period,Criteria,標準
-DocType: Packing Slip Item,Packing Slip Item,包裝單項目
-DocType: Purchase Invoice,Cash/Bank Account,現金／銀行會計科目
-DocType: Travel Itinerary,Train,培養
-apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},請指定{0}
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +74,Removed items with no change in quantity or value.,刪除的項目在數量或價值沒有變化。
-DocType: Delivery Note,Delivery To,交貨給
-apps/erpnext/erpnext/stock/doctype/item/item.js +471,Variant creation has been queued.,變體創建已經排隊。
-DocType: Department,The first Leave Approver in the list will be set as the default Leave Approver.,列表中的第一個請假批准者將被設置為默認的批准批准者。
-apps/erpnext/erpnext/stock/doctype/item/item.py +774,Attribute table is mandatory,屬性表是強制性的
-DocType: Production Plan,Get Sales Orders,獲取銷售訂單
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +69,{0} can not be negative,{0}不能為負數
-apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js +37,Connect to Quickbooks,連接到Quickbooks
-DocType: Training Event,Self-Study,自習
-DocType: POS Closing Voucher,Period End Date,期末結束日期
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64,Row {0}: {1} is required to create the Opening {2} Invoices,行{0}：{1}是創建開始{2}發票所必需的
-DocType: Membership,Membership,籍
-DocType: Asset,Total Number of Depreciations,折舊總數
-DocType: Sales Invoice Item,Rate With Margin,利率保證金
-DocType: Sales Invoice Item,Rate With Margin,利率保證金
-DocType: Purchase Invoice,Is Return (Debit Note),是退貨（借記卡）
-DocType: Workstation,Wages,工資
-DocType: Asset Maintenance,Maintenance Manager Name,維護經理姓名
-DocType: Agriculture Task,Urgent,緊急
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +187,Please specify a valid Row ID for row {0} in table {1},請指定行{0}在表中的有效行ID {1}
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84,Unable to find variable: ,無法找到變量：
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +893,Please select a field to edit from numpad,請選擇要從數字鍵盤編輯的字段
-apps/erpnext/erpnext/stock/doctype/item/item.py +293,Cannot be a fixed asset item as Stock Ledger is created.,不能成為庫存分類賬創建的固定資產項目。
-apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.js +7,Admit,承認
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,轉到桌面和開始使用ERPNext
-apps/erpnext/erpnext/templates/pages/order.js +31,Pay Remaining,支付剩餘
-DocType: Item,Manufacturer,生產廠家
-DocType: Landed Cost Item,Purchase Receipt Item,採購入庫項目
-DocType: Leave Allocation,Total Leaves Encashed,總葉子被掩飾
-DocType: POS Profile,Sales Invoice Payment,銷售發票付款
-DocType: Quality Inspection Template,Quality Inspection Template Name,質量檢驗模板名稱
-DocType: Project,First Email,第一郵件
-DocType: Company,Exception Budget Approver Role,例外預算審批人角色
-DocType: Purchase Invoice,"Once set, this invoice will be on hold till the set date",一旦設置，該發票將被保留至設定的日期
-DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,在銷售訂單/成品倉庫保留倉庫
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69,Selling Amount,銷售金額
-DocType: Repayment Schedule,Interest Amount,利息金額
-DocType: Sales Invoice,Loyalty Amount,忠誠金額
-DocType: Employee Transfer,Employee Transfer Detail,員工轉移詳情
-DocType: Serial No,Creation Document No,文檔創建編號
-DocType: Location,Location Details,位置詳情
-DocType: Share Transfer,Issue,問題
-apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter_dashboard.py +11,Records,記錄
-DocType: Asset,Scrapped,報廢
-DocType: Item,Item Defaults,項目默認值
-DocType: Cashier Closing,Returns,返回
-DocType: Job Card,WIP Warehouse,WIP倉庫
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195,Serial No {0} is under maintenance contract upto {1},序列號{0}在維護合約期間內直到{1}
-DocType: Lead,Organization Name,組織名稱
-DocType: Support Settings,Show Latest Forum Posts,顯示最新的論壇帖子
-DocType: Tax Rule,Shipping State,運輸狀態
-,Projected Quantity as Source,預計庫存量的來源
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item must be added using 'Get Items from Purchase Receipts' button,項目必須使用'從採購入庫“按鈕進行新增
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +914,Delivery Trip,送貨之旅
-DocType: Student,A-,一個-
-DocType: Share Transfer,Transfer Type,轉移類型
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +124,Sales Expenses,銷售費用
-DocType: Diagnosis,Diagnosis,診斷
-apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18,Standard Buying,標準採購
-DocType: Attendance Request,Explanation,說明
-DocType: GL Entry,Against,針對
-DocType: Item Default,Sales Defaults,銷售默認值
-DocType: Sales Order Item,Work Order Qty,工作訂單數量
-DocType: Item Default,Default Selling Cost Center,預設銷售成本中心
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +594,Disc,圓盤
-DocType: Buying Settings,Material Transferred for Subcontract,轉包材料轉讓
-DocType: Email Digest,Purchase Orders Items Overdue,採購訂單項目逾期
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1638,ZIP Code,郵政編碼
-apps/erpnext/erpnext/controllers/selling_controller.py +265,Sales Order {0} is {1},銷售訂單{0} {1}
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +260,Select interest income account in loan {0},選擇貸款{0}中的利息收入科目
-DocType: Opportunity,Contact Info,聯絡方式
-apps/erpnext/erpnext/config/stock.py +322,Making Stock Entries,製作Stock條目
-apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py +15,Cannot promote Employee with status Left,無法提升狀態為Left的員工
-DocType: Packing Slip,Net Weight UOM,淨重計量單位
-DocType: Item Default,Default Supplier,預設的供應商
-DocType: Loan,Repayment Schedule,還款計劃
-DocType: Shipping Rule Condition,Shipping Rule Condition,送貨規則條件
-apps/erpnext/erpnext/hr/doctype/payroll_period/payroll_period.py +19,End Date can not be less than Start Date,結束日期不能小於開始日期
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +262,Invoice can't be made for zero billing hour,在零計費時間內無法開具發票
-DocType: Company,Date of Commencement,開始日期
-DocType: Sales Person,Select company name first.,先選擇公司名稱。
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +380,Email sent to {0},電子郵件發送到{0}
-apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,從供應商收到的報價。
-apps/erpnext/erpnext/config/manufacturing.py +74,Replace BOM and update latest price in all BOMs,更換BOM並更新所有BOM中的最新價格
-apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js +13,This is a root supplier group and cannot be edited.,這是一個根源供應商組，無法編輯。
-DocType: Delivery Note,Driver Name,司機姓名
-apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Average Age,平均年齡
-DocType: Education Settings,Attendance Freeze Date,出勤凍結日期
-DocType: Education Settings,Attendance Freeze Date,出勤凍結日期
-DocType: Payment Request,Inward,向內的
-apps/erpnext/erpnext/utilities/user_progress.py +110,List a few of your suppliers. They could be organizations or individuals.,列出一些你的供應商。他們可以是組織或個人。
-apps/erpnext/erpnext/templates/pages/home.html +32,View All Products,查看所有產品
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),最低鉛年齡（天）
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),最低鉛年齡（天）
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +60,All BOMs,所有的材料明細表
-apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35,Hotel Rooms of type {0} are unavailable on {1},{0}類型的酒店客房不適用於{1}
-DocType: Healthcare Practitioner,Default Currency,預設貨幣
-apps/erpnext/erpnext/controllers/selling_controller.py +150,Maximum discount for Item {0} is {1}%,第{0}項的最大折扣為{1}％
-DocType: Asset Movement,From Employee,從員工
-DocType: Driver,Cellphone Number,手機號碼
-DocType: Project,Monitor Progress,監視進度
-apps/erpnext/erpnext/controllers/accounts_controller.py +545,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,警告： {0} {1}為零，系統將不檢查超收因為金額項目
-DocType: Journal Entry,Make Difference Entry,使不同入口
-DocType: Supplier Quotation,Auto Repeat Section,自動重複部分
-DocType: Appraisal Template Goal,Key Performance Area,關鍵績效區
-DocType: Program Enrollment,Transportation,運輸
-apps/erpnext/erpnext/controllers/item_variant.py +94,Invalid Attribute,無效屬性
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +241,{0} {1} must be submitted,{0} {1}必須提交
-DocType: Buying Settings,Default Supplier Group,默認供應商組
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159,Quantity must be less than or equal to {0},量必須小於或等於{0}
-apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +44,Maximum amount eligible for the component {0} exceeds {1},符合組件{0}的最高金額超過{1}
-DocType: Department Approver,Department Approver,部門批准人
-DocType: QuickBooks Migrator,Application Settings,應用程序設置
-DocType: SMS Center,Total Characters,總字元數
-DocType: Employee Advance,Claimed,聲稱
-DocType: Crop,Row Spacing,行間距
-apps/erpnext/erpnext/controllers/buying_controller.py +204,Please select BOM in BOM field for Item {0},請BOM字段中選擇BOM的項目{0}
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +22,There isn't any item variant for the selected item,所選項目沒有任何項目變體
-DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-表 發票詳細資訊
-DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,付款發票對帳
-apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py +75,Contribution %,貢獻％
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +245,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}",根據購買設置，如果需要採購訂單==&#39;是&#39;，那麼為了創建採購發票，用戶需要首先為項目{0}創建採購訂單
-,HSN-wise-summary of outward supplies,HSN明智的向外供應摘要
-DocType: Company,Company registration numbers for your reference. Tax numbers etc.,公司註冊號碼，供大家參考。稅務號碼等
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +261,To State,國家
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +122,Distributor,經銷商
-DocType: Asset Finance Book,Asset Finance Book,資產融資書
-DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,購物車運輸規則
-apps/erpnext/erpnext/public/js/controllers/transaction.js +72,Please set 'Apply Additional Discount On',請設置“收取額外折扣”
-DocType: Party Tax Withholding Config,Applicable Percent,適用百分比
-,Ordered Items To Be Billed,預付款的訂購物品
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,From Range has to be less than To Range,從範圍必須小於要範圍
-DocType: Global Defaults,Global Defaults,全域預設值
-apps/erpnext/erpnext/projects/doctype/project/project.py +291,Project Collaboration Invitation,項目合作邀請
-DocType: Salary Slip,Deductions,扣除
-DocType: Setup Progress Action,Action Name,動作名稱
-apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js +17,Start Year,開始年份
-apps/erpnext/erpnext/regional/india/utils.py +28,First 2 digits of GSTIN should match with State number {0},GSTIN的前2位數字應與狀態號{0}匹配
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +84,PDC/LC,PDC / LC
-DocType: Purchase Invoice,Start date of current invoice's period,當前發票期間內的開始日期
-DocType: Salary Slip,Leave Without Pay,無薪假
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +366,Capacity Planning Error,產能規劃錯誤
-,Trial Balance for Party,試算表的派對
-DocType: Lead,Consultant,顧問
-apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +356,Parents Teacher Meeting Attendance,家長老師見面會
-DocType: Salary Slip,Earnings,收益
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +538,Finished Item {0} must be entered for Manufacture type entry,完成項目{0}必須為製造類條目進入
-apps/erpnext/erpnext/config/learn.py +87,Opening Accounting Balance,打開會計平衡
-,GST Sales Register,消費稅銷售登記冊
-DocType: Sales Invoice Advance,Sales Invoice Advance,銷售發票提前
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +552,Nothing to request,無需求
-DocType: Stock Settings,Default Return Warehouse,默認退貨倉庫
-apps/erpnext/erpnext/public/js/setup_wizard.js +18,Select your Domains,選擇您的域名
-apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/sync_product.py +228,Shopify Supplier,Shopify供應商
-DocType: Bank Statement Transaction Entry,Payment Invoice Items,付款發票項目
-DocType: Payroll Entry,Employee Details,員工詳細信息
-DocType: Item Variant Settings,Fields will be copied over only at time of creation.,字段將僅在創建時復制。
-apps/erpnext/erpnext/projects/doctype/task/task.py +44,'Actual Start Date' can not be greater than 'Actual End Date',“實際開始日期”不能大於“實際結束日期'
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +390,Management,管理
-DocType: Cheque Print Template,Payer Settings,付款人設置
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +651,No pending Material Requests found to link for the given items.,找不到針對給定項目鏈接的待處理物料請求。
-apps/erpnext/erpnext/public/js/utils/party.js +193,Select company first,首先選擇公司
-DocType: Item Attribute Value,"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""",這將追加到變異的項目代碼。例如，如果你的英文縮寫為“SM”，而該項目的代碼是“T-SHIRT”，該變種的項目代碼將是“T-SHIRT-SM”
-DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,薪資單一被儲存，淨付款就會被顯示出來。
-DocType: Delivery Note,Is Return,退貨
-apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +17,Start day is greater than end day in task '{0}',開始日期大於任務“{0}”的結束日期
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +893,Return / Debit Note,返回/借記注
-DocType: Price List Country,Price List Country,價目表國家
-DocType: Item,UOMs,計量單位
-apps/erpnext/erpnext/stock/utils.py +236,{0} valid serial nos for Item {1},{0}項目{1}的有效的序號
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +61,Item Code cannot be changed for Serial No.,產品編號不能為序列號改變
-DocType: Purchase Invoice Item,UOM Conversion Factor,計量單位換算係數
-apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js +9,Please enter Item Code to get Batch Number,請輸入產品代碼來獲得批號
-DocType: Loyalty Point Entry,Loyalty Point Entry,忠誠度積分
-DocType: Stock Settings,Default Item Group,預設項目群組
-DocType: Job Card,Time In Mins,分鐘時間
-apps/erpnext/erpnext/config/buying.py +38,Supplier database.,供應商數據庫。
-DocType: Contract Template,Contract Terms and Conditions,合同條款和條件
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +425,You cannot restart a Subscription that is not cancelled.,您無法重新啟動未取消的訂閱。
-DocType: Account,Balance Sheet,資產負債表
-DocType: Leave Type,Is Earned Leave,獲得休假
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +797,Cost Center For Item with Item Code ',成本中心與項目代碼“項目
-DocType: Student Report Generation Tool,Total Parents Teacher Meeting,總計家長教師會議
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2530,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.",付款方式未配置。請檢查是否帳戶已就付款方式或POS機配置文件中設置。
-apps/erpnext/erpnext/buying/utils.py +74,Same item cannot be entered multiple times.,同一項目不能輸入多次。
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30,"Further accounts can be made under Groups, but entries can be made against non-Groups",進一步帳戶可以根據組進行，但條目可針對非組進行
-DocType: Lead,Lead,潛在客戶
-DocType: Email Digest,Payables,應付帳款
-DocType: Course,Course Intro,課程介紹
-DocType: Amazon MWS Settings,MWS Auth Token,MWS Auth Token
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +105,Stock Entry {0} created,庫存輸入{0}創建
-apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py +110,You don't have enought Loyalty Points to redeem,您沒有獲得忠誠度積分兌換
-apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py +23,Please set associated account in Tax Withholding Category {0} against Company {1},請在針對公司{1}的預扣稅分類{0}中設置關聯帳戶
-apps/erpnext/erpnext/controllers/buying_controller.py +405,Row #{0}: Rejected Qty can not be entered in Purchase Return,行＃{0}：駁回採購退貨數量不能進入
-apps/erpnext/erpnext/stock/doctype/item/item.js +203,Changing Customer Group for the selected Customer is not allowed.,不允許更改所選客戶的客戶組。
-,Purchase Order Items To Be Billed,欲付款的採購訂單品項
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +77,Updating estimated arrival times.,更新預計到達時間。
-DocType: Program Enrollment Tool,Enrollment Details,註冊詳情
-apps/erpnext/erpnext/stock/doctype/item/item.py +684,Cannot set multiple Item Defaults for a company.,無法為公司設置多個項目默認值。
-DocType: Purchase Invoice Item,Net Rate,淨費率
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +194,Please select a customer,請選擇一個客戶
-DocType: Leave Policy,Leave Allocations,離開分配
-DocType: Purchase Invoice Item,Purchase Invoice Item,採購發票項目
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,針對所選的採購入庫單，存貨帳分錄和總帳分錄已經重新登錄。
-DocType: Student Report Generation Tool,Assessment Terms,評估條款
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,項目1
-DocType: Holiday,Holiday,節日
-apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +25,Leave Type is madatory,離開類型是瘋狂的
-DocType: Support Settings,Close Issue After Days,關閉問題天后
-apps/erpnext/erpnext/public/js/hub/marketplace.js +138,You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,您需要是具有System Manager和Item Manager角色的用戶才能將用戶添加到Marketplace。
-DocType: Leave Control Panel,Leave blank if considered for all branches,保持空白如果考慮到全部分支機構
-DocType: Job Opening,Staffing Plan,人員配備計劃
-DocType: Bank Guarantee,Validity in Days,天數有效
-DocType: Bank Guarantee,Validity in Days,天數有效
-apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21,C-form is not applicable for Invoice: {0},C-形式不適用發票：{0}
-DocType: Certified Consultant,Name of Consultant,顧問的名字
-DocType: Payment Reconciliation,Unreconciled Payment Details,未核銷付款明細
-apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6,Member Activity,會員活動
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,訂單數量
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,訂單數量
-DocType: Global Defaults,Current Fiscal Year,當前會計年度
-DocType: Purchase Invoice,Group same items,組相同的項目
-DocType: Purchase Invoice,Disable Rounded Total,禁用圓角總
-DocType: Marketplace Settings,Sync in Progress,同步進行中
-DocType: Department,Parent Department,家長部門
-DocType: Loan Application,Repayment Info,還款信息
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +486,'Entries' cannot be empty,“分錄”不能是空的
-DocType: Maintenance Team Member,Maintenance Role,維護角色
-apps/erpnext/erpnext/utilities/transaction_base.py +97,Duplicate row {0} with same {1},重複的行{0}同{1}
-DocType: Marketplace Settings,Disable Marketplace,禁用市場
-,Trial Balance,試算表
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +467,Fiscal Year {0} not found,會計年度{0}未找到
-apps/erpnext/erpnext/config/hr.py +394,Setting up Employees,建立職工
-DocType: Hotel Room Reservation,Hotel Reservation User,酒店預訂用戶
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +165,Please select prefix first,請先選擇前綴稱號
-DocType: Subscription Settings,Subscription Settings,訂閱設置
-DocType: Purchase Invoice,Update Auto Repeat Reference,更新自動重複參考
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +273,Optional Holiday List not set for leave period {0},可選假期列表未設置為假期{0}
-DocType: Maintenance Visit Purpose,Work Done,工作完成
-apps/erpnext/erpnext/controllers/item_variant.py +35,Please specify at least one attribute in the Attributes table,請指定屬性表中的至少一個屬性
-DocType: Announcement,All Students,所有學生
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +56,Item {0} must be a non-stock item,項{0}必須是一個非庫存項目
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +18,View Ledger,查看總帳
-DocType: Grading Scale,Intervals,間隔
-DocType: Bank Statement Transaction Entry,Reconciled Transactions,協調的事務
-DocType: Crop Cycle,Linked Location,鏈接位置
-apps/erpnext/erpnext/stock/doctype/item/item.py +557,"An Item Group exists with same name, please change the item name or rename the item group",具有具有相同名稱的項目群組存在，請更改項目名稱或重新命名該項目群組
-apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,學生手機號碼
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105,Rest Of The World,世界其他地區
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,該項目{0}不能有批
-DocType: Crop,Yield UOM,產量UOM
-,Budget Variance Report,預算差異報告
-DocType: Salary Slip,Gross Pay,工資總額
-DocType: Item,Is Item from Hub,是來自Hub的Item
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1642,Get Items from Healthcare Services,從醫療保健服務獲取項目
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124,Row {0}: Activity Type is mandatory.,行{0}：活動類型是強制性的。
-apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +39,Accounting Ledger,會計總帳
-DocType: Asset Value Adjustment,Difference Amount,差額
-DocType: Purchase Invoice,Reverse Charge,反向充電
-DocType: Job Card,Timing Detail,時間細節
-DocType: Purchase Invoice,05-Change in POS,05-更改POS
-DocType: Vehicle Log,Service Detail,服務細節
-DocType: BOM,Item Description,項目說明
-DocType: Student Sibling,Student Sibling,學生兄弟
-DocType: Purchase Invoice,Supplied Items,提供的物品
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85,Please set an active menu for Restaurant {0},請設置餐館{0}的有效菜單
-DocType: Work Order,Qty To Manufacture,製造數量
-DocType: Buying Settings,Maintain same rate throughout purchase cycle,在整個採購週期價格保持一致
-DocType: Opportunity Item,Opportunity Item,項目的機會
-,Student and Guardian Contact Details,學生和監護人聯繫方式
-apps/erpnext/erpnext/accounts/doctype/account/account.js +51,Merge Account,合併科目
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +53,Row {0}: For supplier {0} Email Address is required to send email,行{0}：對於供應商{0}的電郵地址發送電子郵件
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +76,Temporary Opening,臨時開通
-,Employee Leave Balance,員工休假餘額
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +148,Balance for Account {0} must always be {1},科目{0}的餘額必須始終為{1}
-DocType: Patient Appointment,More Info,更多訊息
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +181,Valuation Rate required for Item in row {0},行對項目所需的估值速率{0}
-DocType: Supplier Scorecard,Scorecard Actions,記分卡操作
-apps/erpnext/erpnext/utilities/user_progress.py +169,Example: Masters in Computer Science,舉例：碩士計算機科學
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +67,Supplier {0} not found in {1},在{1}中找不到供應商{0}
-DocType: Purchase Invoice,Rejected Warehouse,拒絕倉庫
-DocType: GL Entry,Against Voucher,對傳票
-DocType: Item Default,Default Buying Cost Center,預設採購成本中心
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6,"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.",為得到最好的 ERPNext 教學，我們建議您花一些時間和觀看這些說明影片。
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +1046,For Default Supplier (optional),對於默認供應商（可選）
-DocType: Supplier Quotation Item,Lead Time in days,交貨天期
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +83,Accounts Payable Summary,應付帳款摘要
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +214,Not authorized to edit frozen Account {0},無權修改凍結帳戶{0}
-DocType: Journal Entry,Get Outstanding Invoices,獲取未付發票
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +84,Sales Order {0} is not valid,銷售訂單{0}無效
-DocType: Supplier Scorecard,Warn for new Request for Quotations,警告新的報價請求
-apps/erpnext/erpnext/utilities/activation.py +91,Purchase orders help you plan and follow up on your purchases,採購訂單幫助您規劃和跟進您的購買
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +146,Lab Test Prescriptions,實驗室測試處方
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +164,"The total Issue / Transfer quantity {0} in Material Request {1}  \
+Billing Address GSTIN,帳單地址GSTIN,
+Total Eligible HRA Exemption,合格的HRA豁免總數
+Evaluate,評估
+Net Hour Rate,淨小時率
+Landed Cost Purchase Receipt,到岸成本採購入庫單
+Default Terms,默認條款
+Criteria,標準
+Packing Slip Item,包裝單項目
+Cash/Bank Account,現金／銀行會計科目
+Train,培養
+Please specify a {0},請指定{0}
+Removed items with no change in quantity or value.,刪除的項目在數量或價值沒有變化。
+Delivery To,交貨給
+Variant creation has been queued.,變體創建已經排隊。
+The first Leave Approver in the list will be set as the default Leave Approver.,列表中的第一個請假批准者將被設置為默認的批准批准者。
+Attribute table is mandatory,屬性表是強制性的
+Get Sales Orders,獲取銷售訂單
+{0} can not be negative,{0}不能為負數
+Connect to Quickbooks,連接到Quickbooks,
+Self-Study,自習
+Period End Date,期末結束日期
+Row {0}: {1} is required to create the Opening {2} Invoices,行{0}：{1}是創建開始{2}發票所必需的
+Membership,籍
+Total Number of Depreciations,折舊總數
+Rate With Margin,利率保證金
+Rate With Margin,利率保證金
+Is Return (Debit Note),是退貨（借記卡）
+Wages,工資
+Maintenance Manager Name,維護經理姓名
+Urgent,緊急
+Please specify a valid Row ID for row {0} in table {1},請指定行{0}在表中的有效行ID {1}
+Unable to find variable: ,無法找到變量：
+Please select a field to edit from numpad,請選擇要從數字鍵盤編輯的字段
+Cannot be a fixed asset item as Stock Ledger is created.,不能成為庫存分類賬創建的固定資產項目。
+Admit,承認
+Go to the Desktop and start using ERPNext,轉到桌面和開始使用ERPNext,
+Pay Remaining,支付剩餘
+Manufacturer,生產廠家
+Purchase Receipt Item,採購入庫項目
+Total Leaves Encashed,總葉子被掩飾
+Sales Invoice Payment,銷售發票付款
+Quality Inspection Template Name,質量檢驗模板名稱
+First Email,第一郵件
+Exception Budget Approver Role,例外預算審批人角色
+"Once set, this invoice will be on hold till the set date",一旦設置，該發票將被保留至設定的日期
+Reserved Warehouse in Sales Order / Finished Goods Warehouse,在銷售訂單/成品倉庫保留倉庫
+Selling Amount,銷售金額
+Interest Amount,利息金額
+Loyalty Amount,忠誠金額
+Employee Transfer Detail,員工轉移詳情
+Creation Document No,文檔創建編號
+Location Details,位置詳情
+Issue,問題
+Records,記錄
+Scrapped,報廢
+Item Defaults,項目默認值
+Returns,返回
+WIP Warehouse,WIP倉庫
+Serial No {0} is under maintenance contract upto {1},序列號{0}在維護合約期間內直到{1}
+Organization Name,組織名稱
+Show Latest Forum Posts,顯示最新的論壇帖子
+Shipping State,運輸狀態
+Projected Quantity as Source,預計庫存量的來源
+Item must be added using 'Get Items from Purchase Receipts' button,項目必須使用'從採購入庫“按鈕進行新增
+Delivery Trip,送貨之旅
+A-,一個-
+Transfer Type,轉移類型
+Sales Expenses,銷售費用
+Diagnosis,診斷
+Standard Buying,標準採購
+Explanation,說明
+Against,針對
+Sales Defaults,銷售默認值
+Work Order Qty,工作訂單數量
+Default Selling Cost Center,預設銷售成本中心
+Disc,圓盤
+Material Transferred for Subcontract,轉包材料轉讓
+Purchase Orders Items Overdue,採購訂單項目逾期
+ZIP Code,郵政編碼
+Sales Order {0} is {1},銷售訂單{0} {1}
+Select interest income account in loan {0},選擇貸款{0}中的利息收入科目
+Contact Info,聯絡方式
+Making Stock Entries,製作Stock條目
+Cannot promote Employee with status Left,無法提升狀態為Left的員工
+Net Weight UOM,淨重計量單位
+Default Supplier,預設的供應商
+Repayment Schedule,還款計劃
+Shipping Rule Condition,送貨規則條件
+End Date can not be less than Start Date,結束日期不能小於開始日期
+Invoice can't be made for zero billing hour,在零計費時間內無法開具發票
+Date of Commencement,開始日期
+Select company name first.,先選擇公司名稱。
+Email sent to {0},電子郵件發送到{0}
+Quotations received from Suppliers.,從供應商收到的報價。
+Replace BOM and update latest price in all BOMs,更換BOM並更新所有BOM中的最新價格
+This is a root supplier group and cannot be edited.,這是一個根源供應商組，無法編輯。
+Driver Name,司機姓名
+Average Age,平均年齡
+Attendance Freeze Date,出勤凍結日期
+Attendance Freeze Date,出勤凍結日期
+Inward,向內的
+List a few of your suppliers. They could be organizations or individuals.,列出一些你的供應商。他們可以是組織或個人。
+View All Products,查看所有產品
+Minimum Lead Age (Days),最低鉛年齡（天）
+Minimum Lead Age (Days),最低鉛年齡（天）
+All BOMs,所有的材料明細表
+Hotel Rooms of type {0} are unavailable on {1},{0}類型的酒店客房不適用於{1}
+Default Currency,預設貨幣
+Maximum discount for Item {0} is {1}%,第{0}項的最大折扣為{1}％
+From Employee,從員工
+Cellphone Number,手機號碼
+Monitor Progress,監視進度
+Warning: System will not check overbilling since amount for Item {0} in {1} is zero,警告： {0} {1}為零，系統將不檢查超收因為金額項目
+Make Difference Entry,使不同入口
+Auto Repeat Section,自動重複部分
+Key Performance Area,關鍵績效區
+Transportation,運輸
+Invalid Attribute,無效屬性
+{0} {1} must be submitted,{0} {1}必須提交
+Default Supplier Group,默認供應商組
+Quantity must be less than or equal to {0},量必須小於或等於{0}
+Maximum amount eligible for the component {0} exceeds {1},符合組件{0}的最高金額超過{1}
+Department Approver,部門批准人
+Application Settings,應用程序設置
+Total Characters,總字元數
+Claimed,聲稱
+Row Spacing,行間距
+Please select BOM in BOM field for Item {0},請BOM字段中選擇BOM的項目{0}
+There isn't any item variant for the selected item,所選項目沒有任何項目變體
+C-Form Invoice Detail,C-表 發票詳細資訊
+Payment Reconciliation Invoice,付款發票對帳
+Contribution %,貢獻％
+"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}",根據購買設置，如果需要採購訂單==&#39;是&#39;，那麼為了創建採購發票，用戶需要首先為項目{0}創建採購訂單
+HSN-wise-summary of outward supplies,HSN明智的向外供應摘要
+Company registration numbers for your reference. Tax numbers etc.,公司註冊號碼，供大家參考。稅務號碼等
+To State,國家
+Distributor,經銷商
+Asset Finance Book,資產融資書
+Shopping Cart Shipping Rule,購物車運輸規則
+Please set 'Apply Additional Discount On',請設置“收取額外折扣”
+Applicable Percent,適用百分比
+Ordered Items To Be Billed,預付款的訂購物品
+From Range has to be less than To Range,從範圍必須小於要範圍
+Global Defaults,全域預設值
+Project Collaboration Invitation,項目合作邀請
+Deductions,扣除
+Action Name,動作名稱
+Start Year,開始年份
+First 2 digits of GSTIN should match with State number {0},GSTIN的前2位數字應與狀態號{0}匹配
+PDC/LC,PDC / LC,
+Start date of current invoice's period,當前發票期間內的開始日期
+Leave Without Pay,無薪假
+Capacity Planning Error,產能規劃錯誤
+Trial Balance for Party,試算表的派對
+Consultant,顧問
+Parents Teacher Meeting Attendance,家長老師見面會
+Earnings,收益
+Finished Item {0} must be entered for Manufacture type entry,完成項目{0}必須為製造類條目進入
+Opening Accounting Balance,打開會計平衡
+GST Sales Register,消費稅銷售登記冊
+Sales Invoice Advance,銷售發票提前
+Nothing to request,無需求
+Default Return Warehouse,默認退貨倉庫
+Select your Domains,選擇您的域名
+Shopify Supplier,Shopify供應商
+Payment Invoice Items,付款發票項目
+Employee Details,員工詳細信息
+Fields will be copied over only at time of creation.,字段將僅在創建時復制。
+'Actual Start Date' can not be greater than 'Actual End Date',“實際開始日期”不能大於“實際結束日期'
+Management,管理
+Payer Settings,付款人設置
+No pending Material Requests found to link for the given items.,找不到針對給定項目鏈接的待處理物料請求。
+Select company first,首先選擇公司
+"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""",這將追加到變異的項目代碼。例如，如果你的英文縮寫為“SM”，而該項目的代碼是“T-SHIRT”，該變種的項目代碼將是“T-SHIRT-SM”
+Net Pay (in words) will be visible once you save the Salary Slip.,薪資單一被儲存，淨付款就會被顯示出來。
+Is Return,退貨
+Start day is greater than end day in task '{0}',開始日期大於任務“{0}”的結束日期
+Return / Debit Note,返回/借記注
+Price List Country,價目表國家
+UOMs,計量單位
+{0} valid serial nos for Item {1},{0}項目{1}的有效的序號
+Item Code cannot be changed for Serial No.,產品編號不能為序列號改變
+UOM Conversion Factor,計量單位換算係數
+Please enter Item Code to get Batch Number,請輸入產品代碼來獲得批號
+Loyalty Point Entry,忠誠度積分
+Default Item Group,預設項目群組
+Time In Mins,分鐘時間
+Supplier database.,供應商數據庫。
+Contract Terms and Conditions,合同條款和條件
+You cannot restart a Subscription that is not cancelled.,您無法重新啟動未取消的訂閱。
+Balance Sheet,資產負債表
+Is Earned Leave,獲得休假
+Cost Center For Item with Item Code ',成本中心與項目代碼“項目
+Total Parents Teacher Meeting,總計家長教師會議
+"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.",付款方式未配置。請檢查是否帳戶已就付款方式或POS機配置文件中設置。
+Same item cannot be entered multiple times.,同一項目不能輸入多次。
+"Further accounts can be made under Groups, but entries can be made against non-Groups",進一步帳戶可以根據組進行，但條目可針對非組進行
+Lead,潛在客戶
+Payables,應付帳款
+Course Intro,課程介紹
+MWS Auth Token,MWS Auth Token,
+Stock Entry {0} created,庫存輸入{0}創建
+You don't have enought Loyalty Points to redeem,您沒有獲得忠誠度積分兌換
+Please set associated account in Tax Withholding Category {0} against Company {1},請在針對公司{1}的預扣稅分類{0}中設置關聯帳戶
+Row #{0}: Rejected Qty can not be entered in Purchase Return,行＃{0}：駁回採購退貨數量不能進入
+Changing Customer Group for the selected Customer is not allowed.,不允許更改所選客戶的客戶組。
+Purchase Order Items To Be Billed,欲付款的採購訂單品項
+Updating estimated arrival times.,更新預計到達時間。
+Enrollment Details,註冊詳情
+Cannot set multiple Item Defaults for a company.,無法為公司設置多個項目默認值。
+Net Rate,淨費率
+Please select a customer,請選擇一個客戶
+Leave Allocations,離開分配
+Purchase Invoice Item,採購發票項目
+Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,針對所選的採購入庫單，存貨帳分錄和總帳分錄已經重新登錄。
+Assessment Terms,評估條款
+Item 1,項目1,
+Holiday,節日
+Leave Type is madatory,離開類型是瘋狂的
+Close Issue After Days,關閉問題天后
+You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,您需要是具有System Manager和Item Manager角色的用戶才能將用戶添加到Marketplace。
+Leave blank if considered for all branches,保持空白如果考慮到全部分支機構
+Staffing Plan,人員配備計劃
+Validity in Days,天數有效
+Validity in Days,天數有效
+C-form is not applicable for Invoice: {0},C-形式不適用發票：{0}
+Name of Consultant,顧問的名字
+Unreconciled Payment Details,未核銷付款明細
+Member Activity,會員活動
+Order Count,訂單數量
+Order Count,訂單數量
+Current Fiscal Year,當前會計年度
+Group same items,組相同的項目
+Disable Rounded Total,禁用圓角總
+Sync in Progress,同步進行中
+Parent Department,家長部門
+Repayment Info,還款信息
+'Entries' cannot be empty,“分錄”不能是空的
+Maintenance Role,維護角色
+Duplicate row {0} with same {1},重複的行{0}同{1}
+Disable Marketplace,禁用市場
+Trial Balance,試算表
+Fiscal Year {0} not found,會計年度{0}未找到
+Setting up Employees,建立職工
+Hotel Reservation User,酒店預訂用戶
+Please select prefix first,請先選擇前綴稱號
+Subscription Settings,訂閱設置
+Update Auto Repeat Reference,更新自動重複參考
+Optional Holiday List not set for leave period {0},可選假期列表未設置為假期{0}
+Work Done,工作完成
+Please specify at least one attribute in the Attributes table,請指定屬性表中的至少一個屬性
+All Students,所有學生
+Item {0} must be a non-stock item,項{0}必須是一個非庫存項目
+View Ledger,查看總帳
+Intervals,間隔
+Reconciled Transactions,協調的事務
+Linked Location,鏈接位置
+"An Item Group exists with same name, please change the item name or rename the item group",具有具有相同名稱的項目群組存在，請更改項目名稱或重新命名該項目群組
+Student Mobile No.,學生手機號碼
+Rest Of The World,世界其他地區
+The Item {0} cannot have Batch,該項目{0}不能有批
+Yield UOM,產量UOM,
+Budget Variance Report,預算差異報告
+Gross Pay,工資總額
+Is Item from Hub,是來自Hub的Item,
+Get Items from Healthcare Services,從醫療保健服務獲取項目
+Row {0}: Activity Type is mandatory.,行{0}：活動類型是強制性的。
+Accounting Ledger,會計總帳
+Difference Amount,差額
+Reverse Charge,反向充電
+Timing Detail,時間細節
+05-Change in POS,05-更改POS,
+Service Detail,服務細節
+Item Description,項目說明
+Student Sibling,學生兄弟
+Supplied Items,提供的物品
+Please set an active menu for Restaurant {0},請設置餐館{0}的有效菜單
+Qty To Manufacture,製造數量
+Maintain same rate throughout purchase cycle,在整個採購週期價格保持一致
+Opportunity Item,項目的機會
+Student and Guardian Contact Details,學生和監護人聯繫方式
+Merge Account,合併科目
+Row {0}: For supplier {0} Email Address is required to send email,行{0}：對於供應商{0}的電郵地址發送電子郵件
+Temporary Opening,臨時開通
+Employee Leave Balance,員工休假餘額
+Balance for Account {0} must always be {1},科目{0}的餘額必須始終為{1}
+More Info,更多訊息
+Valuation Rate required for Item in row {0},行對項目所需的估值速率{0}
+Scorecard Actions,記分卡操作
+Example: Masters in Computer Science,舉例：碩士計算機科學
+Supplier {0} not found in {1},在{1}中找不到供應商{0}
+Rejected Warehouse,拒絕倉庫
+Against Voucher,對傳票
+Default Buying Cost Center,預設採購成本中心
+"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.",為得到最好的 ERPNext 教學，我們建議您花一些時間和觀看這些說明影片。
+For Default Supplier (optional),對於默認供應商（可選）
+Lead Time in days,交貨天期
+Accounts Payable Summary,應付帳款摘要
+Not authorized to edit frozen Account {0},無權修改凍結帳戶{0}
+Get Outstanding Invoices,獲取未付發票
+Sales Order {0} is not valid,銷售訂單{0}無效
+Warn for new Request for Quotations,警告新的報價請求
+Purchase orders help you plan and follow up on your purchases,採購訂單幫助您規劃和跟進您的購買
+Lab Test Prescriptions,實驗室測試處方
+"The total Issue / Transfer quantity {0} in Material Request {1}  \
 							cannot be greater than requested quantity {2} for Item {3}",在材質要求總發行/傳輸量{0} {1} \不能超過請求的數量{2}的項目更大的{3}
-DocType: Shopify Settings,"If Shopify not contains a customer in Order, then while syncing Orders, the system will consider default customer for order",如果Shopify不包含訂單中的客戶，則在同步訂單時，系統會考慮默認客戶訂單
-DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,打開發票創建工具項目
-DocType: Cashier Closing Payments,Cashier Closing Payments,收銀員結算付款
-DocType: Education Settings,Employee Number,員工人數
-DocType: Subscription Settings,Cancel Invoice After Grace Period,在寬限期後取消發票
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67,Case No(s) already in use. Try from Case No {0},案例編號已在使用中（ S） 。從案例沒有嘗試{0}
-DocType: Project,% Completed,％已完成
-,Invoiced Amount (Exculsive Tax),發票金額（Exculsive稅）
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14,Item 2,項目2
-DocType: QuickBooks Migrator,Authorization Endpoint,授權端點
-DocType: Travel Request,International,國際
-DocType: Training Event,Training Event,培訓活動
-DocType: Item,Auto re-order,自動重新排序
-apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,實現總計
-DocType: Employee,Place of Issue,簽發地點
-DocType: Plant Analysis,Laboratory Testing Datetime,實驗室測試日期時間
-DocType: Email Digest,Add Quote,添加報價
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1246,UOM coversion factor required for UOM: {0} in Item: {1},所需的計量單位計量單位：丁文因素：{0}項：{1}
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,Indirect Expenses,間接費用
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +128,Row {0}: Qty is mandatory,列#{0}：數量是強制性的
-DocType: Agriculture Analysis Criteria,Agriculture,農業
-apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js +15,Create Sales Order,創建銷售訂單
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +516,Accounting Entry for Asset,資產會計分錄
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +878,Block Invoice,阻止發票
-apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js +16,Quantity to Make,數量
-apps/erpnext/erpnext/accounts/page/pos/pos.js +801,Sync Master Data,同步主數據
-DocType: Asset Repair,Repair Cost,修理費用
-apps/erpnext/erpnext/utilities/user_progress.py +138,Your Products or Services,您的產品或服務
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +16,Failed to login,登錄失敗
-apps/erpnext/erpnext/controllers/buying_controller.py +629,Asset {0} created,資產{0}已創建
-DocType: Special Test Items,Special Test Items,特殊測試項目
-apps/erpnext/erpnext/public/js/hub/marketplace.js +101,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,您需要是具有System Manager和Item Manager角色的用戶才能在Marketplace上註冊。
-apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +25,As per your assigned Salary Structure you cannot apply for benefits,根據您指定的薪資結構，您無法申請福利
-apps/erpnext/erpnext/stock/doctype/item/item.py +231,Website Image should be a public file or website URL,網站形象應該是一個公共文件或網站網址
-apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +71,This is a root item group and cannot be edited.,這是個根項目群組，且無法被編輯。
-apps/erpnext/erpnext/accounts/doctype/account/account.js +133,Merge,合併
-DocType: Journal Entry Account,Purchase Order,採購訂單
-DocType: Vehicle,Fuel UOM,燃油計量單位
-DocType: Warehouse,Warehouse Contact Info,倉庫聯絡方式
-DocType: Payment Entry,Write Off Difference Amount,核銷金額差異
-DocType: Volunteer,Volunteer Name,志願者姓名
-apps/erpnext/erpnext/controllers/accounts_controller.py +793,Rows with duplicate due dates in other rows were found: {0},發現其他行中具有重複截止日期的行：{0}
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +535,"{0}: Employee email not found, hence email not sent",{0}：未發現員工的電子郵件，因此，電子郵件未發
-apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py +55,No Salary Structure assigned for Employee {0} on given date {1},給定日期{1}的員工{0}沒有分配薪金結構
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85,Shipping rule not applicable for country {0},運費規則不適用於國家/地區{0}
-DocType: Item,Foreign Trade Details,外貿詳細
-,Assessment Plan Status,評估計劃狀態
-DocType: Serial No,Serial No Details,序列號詳細資訊
-DocType: Purchase Invoice Item,Item Tax Rate,項目稅率
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +176,From Party Name,來自黨名
-DocType: Student Group Student,Group Roll Number,組卷編號
-DocType: Student Group Student,Group Roll Number,組卷編號
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +177,"For {0}, only credit accounts can be linked against another debit entry",{0}，只有貸方科目可以連接另一個借方分錄
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +660,Delivery Note {0} is not submitted,送貨單{0}未提交
-apps/erpnext/erpnext/stock/get_item_details.py +167,Item {0} must be a Sub-contracted Item,項{0}必須是一個小項目簽約
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +44,Capital Equipments,資本設備
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.",基於“適用於”欄位是「項目」，「項目群組」或「品牌」，而選擇定價規則。
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +372,Please set the Item Code first,請先設定商品代碼
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +157,Doc Type,文件類型
-apps/erpnext/erpnext/controllers/selling_controller.py +135,Total allocated percentage for sales team should be 100,對於銷售團隊總分配比例應為100
-DocType: Subscription Plan,Billing Interval Count,計費間隔計數
-apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py +10,Appointments and Patient Encounters,預約和患者遭遇
-apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +135,Value missing,價值缺失
-DocType: Employee,Department and Grade,部門和年級
-DocType: Sales Invoice Item,Edit Description,編輯說明
-,Team Updates,團隊更新
-apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js +39,For Supplier,對供應商
-DocType: Account,Setting Account Type helps in selecting this Account in transactions.,設置會計科目類型有助於在交易中選擇該科目。
-DocType: Purchase Invoice,Grand Total (Company Currency),總計（公司貨幣）
-apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Create Print Format,創建打印格式
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,創建費用
-apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},沒有找到所謂的任何項目{0}
-apps/erpnext/erpnext/stock/report/item_prices/item_prices.js +8,Items Filter,物品過濾
-DocType: Supplier Scorecard Criteria,Criteria Formula,標準配方
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,出貨總計
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""",只能有一個運輸規則條件為0或空值“ To值”
-DocType: Patient Appointment,Duration,持續時間
-apps/erpnext/erpnext/controllers/status_updater.py +160,"For an item {0}, quantity must be positive number",對於商品{0}，數量必須是正數
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +76,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,注：該成本中心是一個集團。不能讓反對團體的會計分錄。
-apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +44,Compensatory leave request days not in valid holidays,補休請求天不在有效假期
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +54,Child warehouse exists for this warehouse. You can not delete this warehouse.,兒童倉庫存在這個倉庫。您不能刪除這個倉庫。
-DocType: Item,Website Item Groups,網站項目群組
-DocType: Purchase Invoice,Total (Company Currency),總計（公司貨幣）
-DocType: Daily Work Summary Group,Reminder,提醒
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +304,Accessable Value,可訪問的價值
-apps/erpnext/erpnext/stock/utils.py +231,Serial number {0} entered more than once,序號{0}多次輸入
-DocType: Bank Statement Transaction Invoice Item,Journal Entry,日記帳分錄
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +183,From GSTIN,來自GSTIN
-DocType: Expense Claim Advance,Unclaimed amount,無人認領的金額
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +269,{0} items in progress,正在進行{0}項目
-DocType: Workstation,Workstation Name,工作站名稱
-DocType: Grading Scale Interval,Grade Code,等級代碼
-DocType: POS Item Group,POS Item Group,POS項目組
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,電子郵件摘要：
-apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py +23,Alternative item must not be same as item code,替代項目不能與項目代碼相同
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +644,BOM {0} does not belong to Item {1},BOM {0}不屬於項目{1}
-DocType: Sales Partner,Target Distribution,目標分佈
-DocType: Purchase Invoice,06-Finalization of Provisional assessment,06-定期評估
-DocType: Salary Slip,Bank Account No.,銀行賬號
-DocType: Naming Series,This is the number of the last created transaction with this prefix,這就是以這個前綴的最後一個創建的事務數
-DocType: Supplier Scorecard,"Scorecard variables can be used, as well as:
+"If Shopify not contains a customer in Order, then while syncing Orders, the system will consider default customer for order",如果Shopify不包含訂單中的客戶，則在同步訂單時，系統會考慮默認客戶訂單
+Opening Invoice Creation Tool Item,打開發票創建工具項目
+Cashier Closing Payments,收銀員結算付款
+Employee Number,員工人數
+Cancel Invoice After Grace Period,在寬限期後取消發票
+Case No(s) already in use. Try from Case No {0},案例編號已在使用中（ S） 。從案例沒有嘗試{0}
+% Completed,％已完成
+Invoiced Amount (Exculsive Tax),發票金額（Exculsive稅）
+Item 2,項目2,
+Authorization Endpoint,授權端點
+International,國際
+Training Event,培訓活動
+Auto re-order,自動重新排序
+Total Achieved,實現總計
+Place of Issue,簽發地點
+Laboratory Testing Datetime,實驗室測試日期時間
+Add Quote,添加報價
+UOM coversion factor required for UOM: {0} in Item: {1},所需的計量單位計量單位：丁文因素：{0}項：{1}
+Indirect Expenses,間接費用
+Row {0}: Qty is mandatory,列#{0}：數量是強制性的
+Agriculture,農業
+Create Sales Order,創建銷售訂單
+Accounting Entry for Asset,資產會計分錄
+Block Invoice,阻止發票
+Quantity to Make,數量
+Sync Master Data,同步主數據
+Repair Cost,修理費用
+Your Products or Services,您的產品或服務
+Failed to login,登錄失敗
+Asset {0} created,資產{0}已創建
+Special Test Items,特殊測試項目
+You need to be a user with System Manager and Item Manager roles to register on Marketplace.,您需要是具有System Manager和Item Manager角色的用戶才能在Marketplace上註冊。
+As per your assigned Salary Structure you cannot apply for benefits,根據您指定的薪資結構，您無法申請福利
+Website Image should be a public file or website URL,網站形象應該是一個公共文件或網站網址
+This is a root item group and cannot be edited.,這是個根項目群組，且無法被編輯。
+Merge,合併
+Purchase Order,採購訂單
+Fuel UOM,燃油計量單位
+Warehouse Contact Info,倉庫聯絡方式
+Write Off Difference Amount,核銷金額差異
+Volunteer Name,志願者姓名
+Rows with duplicate due dates in other rows were found: {0},發現其他行中具有重複截止日期的行：{0}
+"{0}: Employee email not found, hence email not sent",{0}：未發現員工的電子郵件，因此，電子郵件未發
+No Salary Structure assigned for Employee {0} on given date {1},給定日期{1}的員工{0}沒有分配薪金結構
+Shipping rule not applicable for country {0},運費規則不適用於國家/地區{0}
+Foreign Trade Details,外貿詳細
+Assessment Plan Status,評估計劃狀態
+Serial No Details,序列號詳細資訊
+Item Tax Rate,項目稅率
+From Party Name,來自黨名
+Group Roll Number,組卷編號
+Group Roll Number,組卷編號
+"For {0}, only credit accounts can be linked against another debit entry",{0}，只有貸方科目可以連接另一個借方分錄
+Delivery Note {0} is not submitted,送貨單{0}未提交
+Item {0} must be a Sub-contracted Item,項{0}必須是一個小項目簽約
+Capital Equipments,資本設備
+"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.",基於“適用於”欄位是「項目」，「項目群組」或「品牌」，而選擇定價規則。
+Please set the Item Code first,請先設定商品代碼
+Doc Type,文件類型
+Total allocated percentage for sales team should be 100,對於銷售團隊總分配比例應為100,
+Billing Interval Count,計費間隔計數
+Appointments and Patient Encounters,預約和患者遭遇
+Value missing,價值缺失
+Department and Grade,部門和年級
+Edit Description,編輯說明
+Team Updates,團隊更新
+For Supplier,對供應商
+Setting Account Type helps in selecting this Account in transactions.,設置會計科目類型有助於在交易中選擇該科目。
+Grand Total (Company Currency),總計（公司貨幣）
+Create Print Format,創建打印格式
+Fee Created,創建費用
+Did not find any item called {0},沒有找到所謂的任何項目{0}
+Items Filter,物品過濾
+Criteria Formula,標準配方
+Total Outgoing,出貨總計
+"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""",只能有一個運輸規則條件為0或空值“ To值”
+Duration,持續時間
+"For an item {0}, quantity must be positive number",對於商品{0}，數量必須是正數
+Note: This Cost Center is a Group. Cannot make accounting entries against groups.,注：該成本中心是一個集團。不能讓反對團體的會計分錄。
+Compensatory leave request days not in valid holidays,補休請求天不在有效假期
+Child warehouse exists for this warehouse. You can not delete this warehouse.,兒童倉庫存在這個倉庫。您不能刪除這個倉庫。
+Website Item Groups,網站項目群組
+Total (Company Currency),總計（公司貨幣）
+Reminder,提醒
+Accessable Value,可訪問的價值
+Serial number {0} entered more than once,序號{0}多次輸入
+Journal Entry,日記帳分錄
+From GSTIN,來自GSTIN,
+Unclaimed amount,無人認領的金額
+{0} items in progress,正在進行{0}項目
+Workstation Name,工作站名稱
+Grade Code,等級代碼
+POS Item Group,POS項目組
+Email Digest:,電子郵件摘要：
+Alternative item must not be same as item code,替代項目不能與項目代碼相同
+BOM {0} does not belong to Item {1},BOM {0}不屬於項目{1}
+Target Distribution,目標分佈
+06-Finalization of Provisional assessment,06-定期評估
+Bank Account No.,銀行賬號
+This is the number of the last created transaction with this prefix,這就是以這個前綴的最後一個創建的事務數
+"Scorecard variables can be used, as well as:
 {total_score} (the total score from that period),
 {period_number} (the number of periods to present day)
 ",可以使用記分卡變量，以及：{total_score}（該期間的總分數），{period_number}（到當前時間段的數量）
-apps/erpnext/erpnext/public/js/setup_wizard.js +254,Collapse All,全部收縮
-apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js +27,Create Purchase Order,創建採購訂單
-DocType: Quality Inspection Reading,Reading 8,閱讀8
-DocType: Inpatient Record,Discharge Note,卸貨說明
-DocType: Purchase Invoice,Taxes and Charges Calculation,稅費計算
-DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,自動存入資產折舊條目
-DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,自動存入資產折舊條目
-DocType: Request for Quotation Supplier,Request for Quotation Supplier,詢價供應商
-DocType: Healthcare Settings,Registration Message,註冊信息
-DocType: Prescription Dosage,Prescription Dosage,處方用量
-DocType: Contract,HR Manager,人力資源經理
-apps/erpnext/erpnext/accounts/party.py +196,Please select a Company,請選擇一個公司
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +70,Privilege Leave,特權休假
-DocType: Purchase Invoice,Supplier Invoice Date,供應商發票日期
-DocType: Asset Settings,This value is used for pro-rata temporis calculation,該值用於按比例計算
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +91,You need to enable Shopping Cart,您需要啟用購物車
-DocType: Payment Entry,Writeoff,註銷
-DocType: Stock Settings,Naming Series Prefix,命名系列前綴
-DocType: Appraisal Template Goal,Appraisal Template Goal,考核目標模板
-DocType: Salary Component,Earning,盈利
-DocType: Supplier Scorecard,Scoring Criteria,評分標準
-DocType: Purchase Invoice,Party Account Currency,黨的科目幣種
-DocType: Delivery Trip,Total Estimated Distance,總估計距離
-,BOM Browser,BOM瀏覽器
-apps/erpnext/erpnext/templates/emails/training_event.html +13,Please update your status for this training event,請更新此培訓活動的狀態
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148,Overlapping conditions found between:,存在重疊的條件：
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +188,Against Journal Entry {0} is already adjusted against some other voucher,對日記條目{0}已經調整一些其他的優惠券
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68,Total Order Value,總訂單價值
-apps/erpnext/erpnext/demo/setup/setup_data.py +341,Food,食物
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +42,Ageing Range 3,老齡範圍3
-DocType: POS Closing Voucher Details,POS Closing Voucher Details,POS關閉憑證詳細信息
-DocType: Shopify Log,Shopify Log,Shopify日誌
-DocType: Inpatient Occupancy,Check In,報到
-DocType: Maintenance Schedule Item,No of Visits,沒有訪問量的
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165,Maintenance Schedule {0} exists against {1},針對{1}存在維護計劃{0}
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36,Enrolling student,招生學生
-apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,Currency of the Closing Account must be {0},關閉科目的貨幣必須是{0}
-apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},對所有目標點的總和應該是100。{0}
-DocType: Project,Start and End Dates,開始和結束日期
-DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,合同模板履行條款
-,Delivered Items To Be Billed,交付項目要被收取
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16,Open BOM {0},開放BOM {0}
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +64,Warehouse cannot be changed for Serial No.,倉庫不能改變序列號
-DocType: Purchase Invoice Item,UOM,UOM
-DocType: Rename Tool,Utilities,公用事業
-DocType: POS Profile,Accounting,會計
-DocType: Asset,Purchase Receipt Amount,採購收據金額
-DocType: Employee Separation,Exit Interview Summary,退出面試摘要
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140,Please select batches for batched item ,請為批量選擇批次
-DocType: Asset,Depreciation Schedules,折舊計劃
-apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py +37,"Support for public app is deprecated. Please setup private app, for more details refer user manual",對公共應用程序的支持已被棄用。請設置私人應用程序，更多詳細信息請參閱用戶手冊
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +202,Following accounts might be selected in GST Settings:,以下帳戶可能在GST設置中選擇：
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +104,Application period cannot be outside leave allocation period,申請期間不能請假外分配週期
-DocType: Activity Cost,Projects,專案
-DocType: Payment Request,Transaction Currency,交易貨幣
-apps/erpnext/erpnext/controllers/buying_controller.py +34,From {0} | {1} {2},從{0} | {1} {2}
-apps/erpnext/erpnext/public/js/hub/marketplace.js +163,Some emails are invalid,有些電子郵件無效
-DocType: Work Order Operation,Operation Description,操作說明
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,不能更改財政年度開始日期和財政年度結束日期，一旦會計年度被保存。
-DocType: Quotation,Shopping Cart,購物車
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,平均每日傳出
-DocType: POS Profile,Campaign,競賽
-DocType: Supplier,Name and Type,名稱和類型
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +64,Approval Status must be 'Approved' or 'Rejected',審批狀態必須被“批准”或“拒絕”
-DocType: Healthcare Practitioner,Contacts and Address,聯繫人和地址
-DocType: Salary Structure,Max Benefits (Amount),最大收益（金額）
-DocType: Purchase Invoice,Contact Person,聯絡人
-apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Expected Start Date' can not be greater than 'Expected End Date',“預計開始日期”不能大於“預計結束日期'
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +107,No data for this period,此期間沒有數據
-DocType: Course Scheduling Tool,Course End Date,課程結束日期
-DocType: Sales Order Item,Planned Quantity,計劃數量
-DocType: Purchase Invoice Item,Item Tax Amount,項目稅額
-DocType: Water Analysis,Water Analysis Criteria,水分析標準
-DocType: Item,Maintain Stock,維護庫存資料
-DocType: Employee,Prefered Email,首選電子郵件
-DocType: Student Admission,Eligibility and Details,資格和細節
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +92,Net Change in Fixed Asset,在固定資產淨變動
-apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py +38,Reqd Qty,需要數量
-DocType: Leave Control Panel,Leave blank if considered for all designations,離開，如果考慮所有指定空白
-apps/erpnext/erpnext/controllers/accounts_controller.py +892,Charge of type 'Actual' in row {0} cannot be included in Item Rate,類型'實際'行{0}的計費，不能被包含在項目單價
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +531,Max: {0},最大數量：{0}
-apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,從日期時間
-DocType: Shopify Settings,For Company,對於公司
-apps/erpnext/erpnext/config/support.py +17,Communication log.,通信日誌。
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +195,"Request for Quotation is disabled to access from portal, for more check portal settings.",詢價被禁止訪問門脈，為更多的檢查門戶設置。
-DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,供應商記分卡評分變量
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Buying Amount,購買金額
-DocType: Sales Invoice,Shipping Address Name,送貨地址名稱
-DocType: Material Request,Terms and Conditions Content,條款及細則內容
-apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18,There were errors creating Course Schedule,創建課程表時出現錯誤
-DocType: Department,The first Expense Approver in the list will be set as the default Expense Approver.,列表中的第一個費用審批人將被設置為默認的費用審批人。
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +611,cannot be greater than 100,不能大於100
-apps/erpnext/erpnext/public/js/hub/marketplace.js +96,You need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,您需要是具有System Manager和Item Manager角色的Administrator以外的用戶才能在Marketplace上註冊。
-apps/erpnext/erpnext/stock/doctype/item/item.py +830,Item {0} is not a stock Item,項{0}不是缺貨登記
-DocType: Maintenance Visit,Unscheduled,計劃外
-DocType: Employee,Owned,擁有的
-DocType: Salary Component,Depends on Leave Without Pay,依賴於無薪休假
-DocType: Pricing Rule,"Higher the number, higher the priority",數字越大，優先級越高
-,Purchase Invoice Trends,購買發票趨勢
-DocType: Travel Itinerary,Gluten Free,不含麩質
-DocType: Loyalty Program Collection,Minimum Total Spent,最低總支出
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +222,"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches",行＃{0}：批次{1}只有{2}數量。請選擇具有{3}數量的其他批次，或將該行拆分成多個行，以便從多個批次中傳遞/發布
-DocType: Loyalty Program,Expiry Duration (in days),到期時間（天）
-DocType: Subscription Plan,Price Determination,價格確定
-apps/erpnext/erpnext/hr/doctype/department/department_tree.js +18,New Department,新部門
-DocType: Compensatory Leave Request,Worked On Holiday,在度假工作
-DocType: Appraisal,Goals,目標
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +399,Select POS Profile,選擇POS配置文件
-DocType: Warranty Claim,Warranty / AMC Status,保修/ AMC狀態
-,Accounts Browser,帳戶瀏覽器
-DocType: Procedure Prescription,Referral,推薦
-DocType: Payment Entry Reference,Payment Entry Reference,付款輸入參考
-DocType: GL Entry,GL Entry,GL報名
-DocType: Support Search Source,Response Options,響應選項
-DocType: HR Settings,Employee Settings,員工設置
-apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.html +13,Loading Payment System,加載支付系統
-,Batch-Wise Balance History,間歇式平衡歷史
-apps/erpnext/erpnext/controllers/accounts_controller.py +1122,Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,行＃{0}：如果金額大於項目{1}的開帳單金額，則無法設置費率。
-apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73,Print settings updated in respective print format,打印設置在相應的打印格式更新
-DocType: Package Code,Package Code,封裝代碼
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +83,Apprentice,學徒
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +106,Negative Quantity is not allowed,負數量是不允許
-DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
+Collapse All,全部收縮
+Create Purchase Order,創建採購訂單
+Reading 8,閱讀8,
+Discharge Note,卸貨說明
+Taxes and Charges Calculation,稅費計算
+Book Asset Depreciation Entry Automatically,自動存入資產折舊條目
+Book Asset Depreciation Entry Automatically,自動存入資產折舊條目
+Request for Quotation Supplier,詢價供應商
+Registration Message,註冊信息
+Prescription Dosage,處方用量
+HR Manager,人力資源經理
+Please select a Company,請選擇一個公司
+Privilege Leave,特權休假
+Supplier Invoice Date,供應商發票日期
+This value is used for pro-rata temporis calculation,該值用於按比例計算
+You need to enable Shopping Cart,您需要啟用購物車
+Writeoff,註銷
+Naming Series Prefix,命名系列前綴
+Appraisal Template Goal,考核目標模板
+Earning,盈利
+Scoring Criteria,評分標準
+Party Account Currency,黨的科目幣種
+Total Estimated Distance,總估計距離
+BOM Browser,BOM瀏覽器
+Please update your status for this training event,請更新此培訓活動的狀態
+Overlapping conditions found between:,存在重疊的條件：
+Against Journal Entry {0} is already adjusted against some other voucher,對日記條目{0}已經調整一些其他的優惠券
+Total Order Value,總訂單價值
+Food,食物
+Ageing Range 3,老齡範圍3,
+POS Closing Voucher Details,POS關閉憑證詳細信息
+Shopify Log,Shopify日誌
+Check In,報到
+No of Visits,沒有訪問量的
+Maintenance Schedule {0} exists against {1},針對{1}存在維護計劃{0}
+Enrolling student,招生學生
+Currency of the Closing Account must be {0},關閉科目的貨幣必須是{0}
+Sum of points for all goals should be 100. It is {0},對所有目標點的總和應該是100。{0}
+Start and End Dates,開始和結束日期
+Contract Template Fulfilment Terms,合同模板履行條款
+Delivered Items To Be Billed,交付項目要被收取
+Open BOM {0},開放BOM {0}
+Warehouse cannot be changed for Serial No.,倉庫不能改變序列號
+UOM,UOM,
+Utilities,公用事業
+Accounting,會計
+Purchase Receipt Amount,採購收據金額
+Exit Interview Summary,退出面試摘要
+Please select batches for batched item ,請為批量選擇批次
+Depreciation Schedules,折舊計劃
+"Support for public app is deprecated. Please setup private app, for more details refer user manual",對公共應用程序的支持已被棄用。請設置私人應用程序，更多詳細信息請參閱用戶手冊
+Following accounts might be selected in GST Settings:,以下帳戶可能在GST設置中選擇：
+Application period cannot be outside leave allocation period,申請期間不能請假外分配週期
+Projects,專案
+Transaction Currency,交易貨幣
+From {0} | {1} {2},從{0} | {1} {2}
+Some emails are invalid,有些電子郵件無效
+Operation Description,操作說明
+Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,不能更改財政年度開始日期和財政年度結束日期，一旦會計年度被保存。
+Shopping Cart,購物車
+Avg Daily Outgoing,平均每日傳出
+Campaign,競賽
+Name and Type,名稱和類型
+Approval Status must be 'Approved' or 'Rejected',審批狀態必須被“批准”或“拒絕”
+Contacts and Address,聯繫人和地址
+Max Benefits (Amount),最大收益（金額）
+Contact Person,聯絡人
+'Expected Start Date' can not be greater than 'Expected End Date',“預計開始日期”不能大於“預計結束日期'
+No data for this period,此期間沒有數據
+Course End Date,課程結束日期
+Planned Quantity,計劃數量
+Item Tax Amount,項目稅額
+Water Analysis Criteria,水分析標準
+Maintain Stock,維護庫存資料
+Prefered Email,首選電子郵件
+Eligibility and Details,資格和細節
+Net Change in Fixed Asset,在固定資產淨變動
+Reqd Qty,需要數量
+Leave blank if considered for all designations,離開，如果考慮所有指定空白
+Charge of type 'Actual' in row {0} cannot be included in Item Rate,類型'實際'行{0}的計費，不能被包含在項目單價
+Max: {0},最大數量：{0}
+From Datetime,從日期時間
+For Company,對於公司
+Communication log.,通信日誌。
+"Request for Quotation is disabled to access from portal, for more check portal settings.",詢價被禁止訪問門脈，為更多的檢查門戶設置。
+Supplier Scorecard Scoring Variable,供應商記分卡評分變量
+Buying Amount,購買金額
+Shipping Address Name,送貨地址名稱
+Terms and Conditions Content,條款及細則內容
+There were errors creating Course Schedule,創建課程表時出現錯誤
+The first Expense Approver in the list will be set as the default Expense Approver.,列表中的第一個費用審批人將被設置為默認的費用審批人。
+cannot be greater than 100,不能大於100,
+You need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,您需要是具有System Manager和Item Manager角色的Administrator以外的用戶才能在Marketplace上註冊。
+Item {0} is not a stock Item,項{0}不是缺貨登記
+Unscheduled,計劃外
+Owned,擁有的
+Depends on Leave Without Pay,依賴於無薪休假
+"Higher the number, higher the priority",數字越大，優先級越高
+Purchase Invoice Trends,購買發票趨勢
+Gluten Free,不含麩質
+Minimum Total Spent,最低總支出
+"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches",行＃{0}：批次{1}只有{2}數量。請選擇具有{3}數量的其他批次，或將該行拆分成多個行，以便從多個批次中傳遞/發布
+Expiry Duration (in days),到期時間（天）
+Price Determination,價格確定
+New Department,新部門
+Worked On Holiday,在度假工作
+Goals,目標
+Select POS Profile,選擇POS配置文件
+Warranty / AMC Status,保修/ AMC狀態
+Accounts Browser,帳戶瀏覽器
+Referral,推薦
+Payment Entry Reference,付款輸入參考
+GL Entry,GL報名
+Response Options,響應選項
+Employee Settings,員工設置
+Loading Payment System,加載支付系統
+Batch-Wise Balance History,間歇式平衡歷史
+Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,行＃{0}：如果金額大於項目{1}的開帳單金額，則無法設置費率。
+Print settings updated in respective print format,打印設置在相應的打印格式更新
+Package Code,封裝代碼
+Apprentice,學徒
+Negative Quantity is not allowed,負數量是不允許
+"Tax detail table fetched from item master as a string and stored in this field.
 Used for Taxes and Charges",從項目主檔獲取的稅務詳細資訊表，成為字串並存儲在這欄位。用於稅賦及費用
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +171,Employee cannot report to himself.,員工不能報告自己。
-DocType: Leave Type,Max Leaves Allowed,允許最大葉子
-DocType: Account,"If the account is frozen, entries are allowed to restricted users.",如果帳戶被凍結，條目被允許受限制的用戶。
-DocType: Email Digest,Bank Balance,銀行結餘
-apps/erpnext/erpnext/accounts/party.py +269,Accounting Entry for {0}: {1} can only be made in currency: {2},會計分錄為{0}：{1}只能在貨幣做：{2}
-DocType: HR Settings,Leave Approver Mandatory In Leave Application,在離職申請中允許Approver為強制性
-DocType: Job Opening,"Job profile, qualifications required etc.",所需的工作概況，學歷等。
-DocType: Journal Entry Account,Account Balance,帳戶餘額
-apps/erpnext/erpnext/config/accounts.py +179,Tax Rule for transactions.,稅收規則進行的交易。
-DocType: Rename Tool,Type of document to rename.,的文件類型進行重命名。
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},{0} {1}：需要客戶對應收帳款{2}
-DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),總稅費和費用（公司貨幣）
-DocType: Weather,Weather Parameter,天氣參數
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +76,Show unclosed fiscal year's P&L balances,顯示未關閉的會計年度的盈虧平衡
-DocType: Item,Asset Naming Series,資產命名系列
-apps/erpnext/erpnext/regional/india/utils.py +179,House rented dates should be atleast 15 days apart,出租房屋的日期應至少相隔15天
-DocType: Clinical Procedure Template,Collection Details,收集細節
-DocType: POS Profile,Allow Print Before Pay,付款前允許打印
-DocType: Linked Soil Texture,Linked Soil Texture,連接的土壤紋理
-DocType: Shipping Rule,Shipping Account,送貨科目
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +93,{0} {1}: Account {2} is inactive,{0} {1}科目{2}無效
-apps/erpnext/erpnext/utilities/activation.py +82,Make Sales Orders to help you plan your work and deliver on-time,製作銷售訂單，以幫助你計劃你的工作和按時交付
-DocType: Bank Statement Transaction Entry,Bank Transaction Entries,銀行交易分錄
-DocType: Quality Inspection,Readings,閱讀
-DocType: Stock Entry,Total Additional Costs,總額外費用
-apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py +47,No of Interactions,沒有相互作用
-DocType: BOM,Scrap Material Cost(Company Currency),廢料成本（公司貨幣）
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +44,Sub Assemblies,子組件
-DocType: Asset,Asset Name,資產名稱
-DocType: Project,Task Weight,任務重
-DocType: Loyalty Program,Loyalty Program Type,忠誠度計劃類型
-DocType: Asset Movement,Stock Manager,庫存管理
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +250,Source warehouse is mandatory for row {0},列{0}的來源倉是必要的
-apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38,The Payment Term at row {0} is possibly a duplicate.,第{0}行的支付條款可能是重複的。
-apps/erpnext/erpnext/public/js/setup_wizard.js +30,Agriculture (beta),農業（測試版）
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +919,Packing Slip,包裝單
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Office Rent,辦公室租金
-apps/erpnext/erpnext/config/setup.py +105,Setup SMS gateway settings,設置短信閘道設置
-DocType: Disease,Common Name,通用名稱
-DocType: Employee Boarding Activity,Employee Boarding Activity,員工寄宿活動
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61,Import Failed!,導入失敗！
-apps/erpnext/erpnext/public/js/templates/address_list.html +20,No address added yet.,尚未新增地址。
-DocType: Workstation Working Hour,Workstation Working Hour,工作站工作時間
-DocType: Vital Signs,Blood Pressure,血壓
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88,Analyst,分析人士
-apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +20,{0} is not in a valid Payroll Period,{0}不在有效的工資核算期間
-DocType: Item,Inventory,庫存
-DocType: Item,Sales Details,銷售詳細資訊
-DocType: Opportunity,With Items,隨著項目
-DocType: Asset Maintenance,Maintenance Team,維修隊
-DocType: Salary Component,Is Additional Component,是附加組件
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,在數量
-DocType: Education Settings,Validate Enrolled Course for Students in Student Group,驗證學生組學生入學課程
-DocType: Notification Control,Expense Claim Rejected,費用索賠被拒絕
-DocType: Item,Item Attribute,項目屬性
-apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40,Expense Claim {0} already exists for the Vehicle Log,報銷{0}已經存在車輛日誌
-DocType: Asset Movement,Source Location,來源地點
-apps/erpnext/erpnext/public/js/setup_wizard.js +64,Institute Name,學院名稱
-apps/erpnext/erpnext/hr/doctype/loan/loan.py +127,Please enter repayment Amount,請輸入還款金額
-apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +18,There can be multiple tiered collection factor based on the total spent. But the conversion factor for redemption will always be same for all the tier.,根據總花費可以有多個分層收集因子。但兌換的兌換係數對於所有等級總是相同的。
-apps/erpnext/erpnext/config/stock.py +312,Item Variants,項目變體
-apps/erpnext/erpnext/public/js/setup_wizard.js +29,Services,服務
-DocType: HR Settings,Email Salary Slip to Employee,電子郵件工資單給員工
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1098,Select Possible Supplier,選擇潛在供應商
-DocType: Customer,"Select, to make the customer searchable with these fields",選擇，使客戶可以使用這些字段進行搜索
-DocType: Shopify Settings,Import Delivery Notes from Shopify on Shipment,在發貨時從Shopify導入交貨單
-apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,顯示關閉
-DocType: Leave Type,Is Leave Without Pay,是無薪休假
-apps/erpnext/erpnext/stock/doctype/item/item.py +290,Asset Category is mandatory for Fixed Asset item,資產類別是強制性的固定資產項目
-DocType: Fee Validity,Fee Validity,費用有效期
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +146,No records found in the Payment table,沒有在支付表中找到記錄
-apps/erpnext/erpnext/education/utils.py +19,This {0} conflicts with {1} for {2} {3},此{0}衝突{1}在{2} {3}
-DocType: Student Attendance Tool,Students HTML,學生HTML
-DocType: GST HSN Code,GST HSN Code,GST HSN代碼
-DocType: Employee External Work History,Total Experience,總經驗
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70,Open Projects,打開項目
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +300,Packing Slip(s) cancelled,包裝單（ S）已取消
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +90,Cash Flow from Investing,從投資現金流
-DocType: Program Course,Program Course,課程計劃
-DocType: Healthcare Service Unit,Allow Appointments,允許約會
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Freight and Forwarding Charges,貨運代理費
-DocType: Homepage,Company Tagline for website homepage,公司標語的網站主頁
-DocType: Item Group,Item Group Name,項目群組名稱
-apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +28,Taken,拍攝
-DocType: Student,Date of Leaving,離開日期
-DocType: Pricing Rule,For Price List,對於價格表
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27,Executive Search,獵頭
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +56,Setting defaults,設置默認值
-DocType: Loyalty Program,Auto Opt In (For all customers),自動選擇（適用於所有客戶）
-apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,建立潛在客戶
-DocType: Maintenance Schedule,Schedules,時間表
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +515,POS Profile is required to use Point-of-Sale,POS配置文件需要使用銷售點
-DocType: Cashier Closing,Net Amount,淨額
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +139,{0} {1} has not been submitted so the action cannot be completed,"{0} {1} 尚未提交, 因此無法完成操作"
-DocType: Purchase Order Item Supplied,BOM Detail No,BOM表詳細編號
-DocType: Landed Cost Voucher,Additional Charges,附加費用
-DocType: Support Search Source,Result Route Field,結果路由字段
-DocType: Purchase Invoice,Additional Discount Amount (Company Currency),額外的優惠金額（公司貨幣）
-DocType: Supplier Scorecard,Supplier Scorecard,供應商記分卡
-DocType: Plant Analysis,Result Datetime,結果日期時間
-,Support Hour Distribution,支持小時分配
-DocType: Maintenance Visit,Maintenance Visit,維護訪問
-DocType: Student,Leaving Certificate Number,畢業證書號碼
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +100,"Appointment cancelled, Please review and cancel the invoice {0}",預約已取消，請查看並取消發票{0}
-DocType: Sales Invoice Item,Available Batch Qty at Warehouse,可用的批次數量在倉庫
-DocType: Bank Account,Is Company Account,是公司帳戶
-apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py +58,Leave Type {0} is not encashable,離開類型{0}不可放置
-DocType: Landed Cost Voucher,Landed Cost Help,到岸成本幫助
-DocType: Purchase Invoice,Select Shipping Address,選擇送貨地址
-DocType: Timesheet Detail,Expected Hrs,預計的小時數
-apps/erpnext/erpnext/config/non_profit.py +28,Memebership Details,Memebership細節
-DocType: Leave Block List,Block Holidays on important days.,重要的日子中封鎖假期。
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +194,Please input all required Result Value(s),請輸入所有必需的結果值（s）
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +142,Accounts Receivable Summary,應收帳款匯總
-DocType: POS Closing Voucher,Linked Invoices,鏈接的發票
-DocType: Loan,Monthly Repayment Amount,每月還款額
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9,Opening Invoices,打開發票
-DocType: Contract,Contract Details,合同細節
-DocType: Employee,Leave Details,留下細節
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +218,Please set User ID field in an Employee record to set Employee Role,請在員工記錄設定員工角色設置用戶ID字段
-DocType: UOM,UOM Name,計量單位名稱
-DocType: GST HSN Code,HSN Code,HSN代碼
-apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py +87,Contribution Amount,貢獻金額
-DocType: Purchase Invoice,Shipping Address,送貨地址
-DocType: Stock Reconciliation,This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,此工具可幫助您更新或修復系統中的庫存數量和價值。它通常被用於同步系統值和實際存在於您的倉庫。
-DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,送貨單一被儲存，就會顯示出來。
-apps/erpnext/erpnext/erpnext_integrations/utils.py +22,Unverified Webhook Data,未經驗證的Webhook數據
-apps/erpnext/erpnext/education/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},學生{0}  -  {1}出現連續中多次{2}和{3}
-DocType: Item Alternative,Two-way,雙向
-DocType: Project,Day to Send,發送日
-DocType: Healthcare Settings,Manage Sample Collection,管理樣品收集
-DocType: Production Plan,Ignore Existing Ordered Quantity,忽略現有的訂購數量
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +73,Please set the series to be used.,請設置要使用的系列。
-DocType: Patient,Tobacco Past Use,煙草過去使用
-DocType: Travel Itinerary,Mode of Travel,旅行模式
-DocType: Sales Invoice Item,Brand Name,商標名稱
-DocType: Purchase Receipt,Transporter Details,貨運公司細節
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2714,Default warehouse is required for selected item,默認倉庫需要選中的項目
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1095,Possible Supplier,可能的供應商
-DocType: Budget,Monthly Distribution,月度分佈
-apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +72,Receiver List is empty. Please create Receiver List,收受方列表為空。請創建收受方列表
-apps/erpnext/erpnext/public/js/setup_wizard.js +31,Healthcare (beta),醫療保健（beta）
-DocType: Production Plan Sales Order,Production Plan Sales Order,生產計劃銷售訂單
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +433,"No active BOM found for item {0}. Delivery by \
+Employee cannot report to himself.,員工不能報告自己。
+Max Leaves Allowed,允許最大葉子
+"If the account is frozen, entries are allowed to restricted users.",如果帳戶被凍結，條目被允許受限制的用戶。
+Bank Balance,銀行結餘
+Accounting Entry for {0}: {1} can only be made in currency: {2},會計分錄為{0}：{1}只能在貨幣做：{2}
+Leave Approver Mandatory In Leave Application,在離職申請中允許Approver為強制性
+"Job profile, qualifications required etc.",所需的工作概況，學歷等。
+Account Balance,帳戶餘額
+Tax Rule for transactions.,稅收規則進行的交易。
+Type of document to rename.,的文件類型進行重命名。
+{0} {1}: Customer is required against Receivable account {2},{0} {1}：需要客戶對應收帳款{2}
+Total Taxes and Charges (Company Currency),總稅費和費用（公司貨幣）
+Weather Parameter,天氣參數
+Show unclosed fiscal year's P&L balances,顯示未關閉的會計年度的盈虧平衡
+Asset Naming Series,資產命名系列
+House rented dates should be atleast 15 days apart,出租房屋的日期應至少相隔15天
+Collection Details,收集細節
+Allow Print Before Pay,付款前允許打印
+Linked Soil Texture,連接的土壤紋理
+Shipping Account,送貨科目
+{0} {1}: Account {2} is inactive,{0} {1}科目{2}無效
+Make Sales Orders to help you plan your work and deliver on-time,製作銷售訂單，以幫助你計劃你的工作和按時交付
+Bank Transaction Entries,銀行交易分錄
+Readings,閱讀
+Total Additional Costs,總額外費用
+No of Interactions,沒有相互作用
+Scrap Material Cost(Company Currency),廢料成本（公司貨幣）
+Sub Assemblies,子組件
+Asset Name,資產名稱
+Task Weight,任務重
+Loyalty Program Type,忠誠度計劃類型
+Stock Manager,庫存管理
+Source warehouse is mandatory for row {0},列{0}的來源倉是必要的
+The Payment Term at row {0} is possibly a duplicate.,第{0}行的支付條款可能是重複的。
+Agriculture (beta),農業（測試版）
+Packing Slip,包裝單
+Office Rent,辦公室租金
+Setup SMS gateway settings,設置短信閘道設置
+Common Name,通用名稱
+Employee Boarding Activity,員工寄宿活動
+Import Failed!,導入失敗！
+No address added yet.,尚未新增地址。
+Workstation Working Hour,工作站工作時間
+Blood Pressure,血壓
+Analyst,分析人士
+{0} is not in a valid Payroll Period,{0}不在有效的工資核算期間
+Inventory,庫存
+Sales Details,銷售詳細資訊
+With Items,隨著項目
+Maintenance Team,維修隊
+Is Additional Component,是附加組件
+In Qty,在數量
+Validate Enrolled Course for Students in Student Group,驗證學生組學生入學課程
+Expense Claim Rejected,費用索賠被拒絕
+Item Attribute,項目屬性
+Expense Claim {0} already exists for the Vehicle Log,報銷{0}已經存在車輛日誌
+Source Location,來源地點
+Institute Name,學院名稱
+Please enter repayment Amount,請輸入還款金額
+There can be multiple tiered collection factor based on the total spent. But the conversion factor for redemption will always be same for all the tier.,根據總花費可以有多個分層收集因子。但兌換的兌換係數對於所有等級總是相同的。
+Item Variants,項目變體
+Services,服務
+Email Salary Slip to Employee,電子郵件工資單給員工
+Select Possible Supplier,選擇潛在供應商
+"Select, to make the customer searchable with these fields",選擇，使客戶可以使用這些字段進行搜索
+Import Delivery Notes from Shopify on Shipment,在發貨時從Shopify導入交貨單
+Show closed,顯示關閉
+Is Leave Without Pay,是無薪休假
+Asset Category is mandatory for Fixed Asset item,資產類別是強制性的固定資產項目
+Fee Validity,費用有效期
+No records found in the Payment table,沒有在支付表中找到記錄
+This {0} conflicts with {1} for {2} {3},此{0}衝突{1}在{2} {3}
+Students HTML,學生HTML,
+GST HSN Code,GST HSN代碼
+Total Experience,總經驗
+Open Projects,打開項目
+Packing Slip(s) cancelled,包裝單（ S）已取消
+Cash Flow from Investing,從投資現金流
+Program Course,課程計劃
+Allow Appointments,允許約會
+Freight and Forwarding Charges,貨運代理費
+Company Tagline for website homepage,公司標語的網站主頁
+Item Group Name,項目群組名稱
+Taken,拍攝
+Date of Leaving,離開日期
+For Price List,對於價格表
+Executive Search,獵頭
+Setting defaults,設置默認值
+Auto Opt In (For all customers),自動選擇（適用於所有客戶）
+Create Leads,建立潛在客戶
+Schedules,時間表
+POS Profile is required to use Point-of-Sale,POS配置文件需要使用銷售點
+Net Amount,淨額
+{0} {1} has not been submitted so the action cannot be completed,"{0} {1} 尚未提交, 因此無法完成操作"
+BOM Detail No,BOM表詳細編號
+Additional Charges,附加費用
+Result Route Field,結果路由字段
+Additional Discount Amount (Company Currency),額外的優惠金額（公司貨幣）
+Supplier Scorecard,供應商記分卡
+Result Datetime,結果日期時間
+Support Hour Distribution,支持小時分配
+Maintenance Visit,維護訪問
+Leaving Certificate Number,畢業證書號碼
+"Appointment cancelled, Please review and cancel the invoice {0}",預約已取消，請查看並取消發票{0}
+Available Batch Qty at Warehouse,可用的批次數量在倉庫
+Is Company Account,是公司帳戶
+Leave Type {0} is not encashable,離開類型{0}不可放置
+Landed Cost Help,到岸成本幫助
+Select Shipping Address,選擇送貨地址
+Expected Hrs,預計的小時數
+Memebership Details,Memebership細節
+Block Holidays on important days.,重要的日子中封鎖假期。
+Please input all required Result Value(s),請輸入所有必需的結果值（s）
+Accounts Receivable Summary,應收帳款匯總
+Linked Invoices,鏈接的發票
+Monthly Repayment Amount,每月還款額
+Opening Invoices,打開發票
+Contract Details,合同細節
+Leave Details,留下細節
+Please set User ID field in an Employee record to set Employee Role,請在員工記錄設定員工角色設置用戶ID字段
+UOM Name,計量單位名稱
+HSN Code,HSN代碼
+Contribution Amount,貢獻金額
+Shipping Address,送貨地址
+This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,此工具可幫助您更新或修復系統中的庫存數量和價值。它通常被用於同步系統值和實際存在於您的倉庫。
+In Words will be visible once you save the Delivery Note.,送貨單一被儲存，就會顯示出來。
+Unverified Webhook Data,未經驗證的Webhook數據
+Student {0} - {1} appears Multiple times in row {2} & {3},學生{0}  -  {1}出現連續中多次{2}和{3}
+Two-way,雙向
+Day to Send,發送日
+Manage Sample Collection,管理樣品收集
+Ignore Existing Ordered Quantity,忽略現有的訂購數量
+Please set the series to be used.,請設置要使用的系列。
+Tobacco Past Use,煙草過去使用
+Mode of Travel,旅行模式
+Brand Name,商標名稱
+Transporter Details,貨運公司細節
+Default warehouse is required for selected item,默認倉庫需要選中的項目
+Possible Supplier,可能的供應商
+Monthly Distribution,月度分佈
+Receiver List is empty. Please create Receiver List,收受方列表為空。請創建收受方列表
+Healthcare (beta),醫療保健（beta）
+Production Plan Sales Order,生產計劃銷售訂單
+"No active BOM found for item {0}. Delivery by \
 						Serial No cannot be ensured",未找到項{0}的有效BOM。無法確保交貨\串口號
-DocType: Sales Partner,Sales Partner Target,銷售合作夥伴目標
-DocType: Loan Type,Maximum Loan Amount,最高貸款額度
-DocType: Pricing Rule,Pricing Rule,定價規則
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},學生{0}的重複卷號
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},學生{0}的重複卷號
-apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,材料要求採購訂單
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +79,Row # {0}: Returned Item {1} does not exists in {2} {3},行＃{0}：返回的項目{1}不存在{2} {3}
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16,Bank Accounts,銀行帳戶
-,Bank Reconciliation Statement,銀行對帳表
-DocType: Patient Encounter,Medical Coding,醫學編碼
-,Lead Name,主導者名稱
-,POS,POS
-apps/erpnext/erpnext/config/stock.py +317,Opening Stock Balance,期初存貨餘額
-DocType: Asset Category Account,Capital Work In Progress Account,資本工作進行中的帳戶
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +92,Asset Value Adjustment,資產價值調整
-DocType: Additional Salary,Payroll Date,工資日期
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58,{0} must appear only once,{0}必須只出現一次
-apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,Leaves Allocated Successfully for {0},{0}的排假成功
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42,No Items to pack,無項目包裝
-DocType: Shipping Rule Condition,From Value,從價值
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +717,Manufacturing Quantity is mandatory,生產數量是必填的
-DocType: Loan,Repayment Method,還款方式
-DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website",如果選中，主頁將是網站的默認項目組
-DocType: Quality Inspection Reading,Reading 4,4閱讀
-apps/erpnext/erpnext/utilities/activation.py +118,"Students are at the heart of the system, add all your students",學生在系統的心臟，添加所有的學生
-apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py +16,Member ID,會員ID
-DocType: Employee Tax Exemption Proof Submission,Monthly Eligible Amount,每月合格金額
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},行＃{0}：清除日期{1}無法支票日期前{2}
-DocType: Asset Maintenance Task,Certificate Required,證書要求
-DocType: Company,Default Holiday List,預設假日表列
-DocType: Pricing Rule,Supplier Group,供應商集團
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +163,Row {0}: From Time and To Time of {1} is overlapping with {2},行{0}：從時間和結束時間{1}是具有重疊{2}
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +152,Stock Liabilities,現貨負債
-DocType: Purchase Invoice,Supplier Warehouse,供應商倉庫
-DocType: Opportunity,Contact Mobile No,聯絡手機號碼
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +53,Select Company,選擇公司
-,Material Requests for which Supplier Quotations are not created,尚未建立供應商報價的材料需求
-DocType: Staffing Plan Detail,Estimated Cost Per Position,估計的每位成本
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34,User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,用戶{0}沒有任何默認的POS配置文件。檢查此用戶的行{1}處的默認值。
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +166,Employee Referral,員工推薦
-DocType: Student Group,Set 0 for no limit,為不限制設為0
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +191,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,這一天（S）對你所申請休假的假期。你不需要申請許可。
-DocType: Customer,Primary Address and Contact Detail,主要地址和聯繫人詳情
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +21,Resend Payment Email,重新發送付款電子郵件
-apps/erpnext/erpnext/templates/pages/projects.html +27,New task,新任務
-DocType: Clinical Procedure,Appointment,約定
-apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,請報價
-apps/erpnext/erpnext/config/education.py +230,Other Reports,其他報告
-apps/erpnext/erpnext/public/js/setup_wizard.js +39,Please select at least one domain.,請選擇至少一個域名。
-DocType: Dependent Task,Dependent Task,相關任務
-DocType: Shopify Settings,Shopify Tax Account,Shopify稅收帳戶
-apps/erpnext/erpnext/stock/doctype/item/item.py +475,Conversion factor for default Unit of Measure must be 1 in row {0},預設計量單位的轉換因子必須是1在行{0}
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +257,Leave of type {0} cannot be longer than {1},請假類型{0}不能長於{1}
-DocType: Delivery Trip,Optimize Route,優化路線
-DocType: Manufacturing Settings,Try planning operations for X days in advance.,嘗試提前X天規劃作業。
-apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py +90,"{0} vacancies and {1} budget for {2} already planned for subsidiary companies of {3}. \
+Sales Partner Target,銷售合作夥伴目標
+Maximum Loan Amount,最高貸款額度
+Pricing Rule,定價規則
+Duplicate roll number for student {0},學生{0}的重複卷號
+Duplicate roll number for student {0},學生{0}的重複卷號
+Material Request to Purchase Order,材料要求採購訂單
+Row # {0}: Returned Item {1} does not exists in {2} {3},行＃{0}：返回的項目{1}不存在{2} {3}
+Bank Accounts,銀行帳戶
+Bank Reconciliation Statement,銀行對帳表
+Medical Coding,醫學編碼
+Lead Name,主導者名稱
+POS,POS,
+Opening Stock Balance,期初存貨餘額
+Capital Work In Progress Account,資本工作進行中的帳戶
+Asset Value Adjustment,資產價值調整
+Payroll Date,工資日期
+{0} must appear only once,{0}必須只出現一次
+Leaves Allocated Successfully for {0},{0}的排假成功
+No Items to pack,無項目包裝
+From Value,從價值
+Manufacturing Quantity is mandatory,生產數量是必填的
+Repayment Method,還款方式
+"If checked, the Home page will be the default Item Group for the website",如果選中，主頁將是網站的默認項目組
+Reading 4,4閱讀
+"Students are at the heart of the system, add all your students",學生在系統的心臟，添加所有的學生
+Member ID,會員ID,
+Monthly Eligible Amount,每月合格金額
+Row #{0}: Clearance date {1} cannot be before Cheque Date {2},行＃{0}：清除日期{1}無法支票日期前{2}
+Certificate Required,證書要求
+Default Holiday List,預設假日表列
+Supplier Group,供應商集團
+Row {0}: From Time and To Time of {1} is overlapping with {2},行{0}：從時間和結束時間{1}是具有重疊{2}
+Stock Liabilities,現貨負債
+Supplier Warehouse,供應商倉庫
+Contact Mobile No,聯絡手機號碼
+Select Company,選擇公司
+Material Requests for which Supplier Quotations are not created,尚未建立供應商報價的材料需求
+Estimated Cost Per Position,估計的每位成本
+User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,用戶{0}沒有任何默認的POS配置文件。檢查此用戶的行{1}處的默認值。
+Employee Referral,員工推薦
+Set 0 for no limit,為不限制設為0,
+The day(s) on which you are applying for leave are holidays. You need not apply for leave.,這一天（S）對你所申請休假的假期。你不需要申請許可。
+Primary Address and Contact Detail,主要地址和聯繫人詳情
+Resend Payment Email,重新發送付款電子郵件
+New task,新任務
+Appointment,約定
+Make Quotation,請報價
+Other Reports,其他報告
+Please select at least one domain.,請選擇至少一個域名。
+Dependent Task,相關任務
+Shopify Tax Account,Shopify稅收帳戶
+Conversion factor for default Unit of Measure must be 1 in row {0},預設計量單位的轉換因子必須是1在行{0}
+Leave of type {0} cannot be longer than {1},請假類型{0}不能長於{1}
+Optimize Route,優化路線
+Try planning operations for X days in advance.,嘗試提前X天規劃作業。
+"{0} vacancies and {1} budget for {2} already planned for subsidiary companies of {3}. \
 				You can only plan for upto {4} vacancies and and budget {5} as per staffing plan {6} for parent company {3}.",已為{3}的子公司計劃{2}的{0}空缺和{1}預算。 \根據母公司{3}的員工計劃{6}，您只能計劃最多{4}個職位空缺和預算{5}。
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +207,Please set Default Payroll Payable Account in Company {0},請公司設定默認應付職工薪酬帳戶{0}
-DocType: Amazon MWS Settings,Get financial breakup of Taxes and charges data by Amazon ,通過亞馬遜獲取稅收和收費數據的財務分解
-DocType: SMS Center,Receiver List,收受方列表
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1108,Search Item,搜索項目
-DocType: Payment Schedule,Payment Amount,付款金額
-apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +20,Half Day Date should be in between Work From Date and Work End Date,半天日期應在工作日期和工作結束日期之間
-DocType: Healthcare Settings,Healthcare Service Items,醫療服務項目
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +69,Net Change in Cash,現金淨變動
-DocType: Assessment Plan,Grading Scale,分級量表
-apps/erpnext/erpnext/stock/doctype/item/item.py +469,Unit of Measure {0} has been entered more than once in Conversion Factor Table,計量單位{0}已經進入不止一次在轉換係數表
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +617,Already completed,已經完成
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +34,Stock In Hand,庫存在手
-apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +68,"Please add the remaining benefits {0} to the application as \
+Please set Default Payroll Payable Account in Company {0},請公司設定默認應付職工薪酬帳戶{0}
+Get financial breakup of Taxes and charges data by Amazon ,通過亞馬遜獲取稅收和收費數據的財務分解
+Receiver List,收受方列表
+Search Item,搜索項目
+Payment Amount,付款金額
+Half Day Date should be in between Work From Date and Work End Date,半天日期應在工作日期和工作結束日期之間
+Healthcare Service Items,醫療服務項目
+Net Change in Cash,現金淨變動
+Grading Scale,分級量表
+Unit of Measure {0} has been entered more than once in Conversion Factor Table,計量單位{0}已經進入不止一次在轉換係數表
+Already completed,已經完成
+Stock In Hand,庫存在手
+"Please add the remaining benefits {0} to the application as \
 				pro-rata component",請將剩餘的權益{0}作為\ pro-rata組件添加到應用程序中
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64,Import Successful!,導入成功！
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +35,Payment Request already exists {0},付款申請已經存在{0}
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,發布項目成本
-DocType: Healthcare Practitioner,Hospital,醫院
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +534,Quantity must not be more than {0},數量必須不超過{0}
-DocType: Travel Request Costing,Funded Amount,資助金額
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +120,Previous Financial Year is not closed,上一財政年度未關閉
-DocType: Practitioner Schedule,Practitioner Schedule,從業者時間表
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +84,Age (Days),時間（天）
-DocType: Additional Salary,Additional Salary,額外的薪水
-DocType: Quotation Item,Quotation Item,產品報價
-DocType: Customer,Customer POS Id,客戶POS ID
-DocType: Account,Account Name,帳戶名稱
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +536,From Date cannot be greater than To Date,起始日期不能大於結束日期
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +203,Serial No {0} quantity {1} cannot be a fraction,序列號{0}的數量量{1}不能是分數
-apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py +96,Please enter Woocommerce Server URL,請輸入Woocommerce服務器網址
-DocType: Purchase Order Item,Supplier Part Number,供應商零件編號
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +137,Conversion rate cannot be 0 or 1,轉化率不能為0或1
-apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py +27,All the mandatory Task for employee creation hasn't been done yet.,所有員工創建的強制性任務尚未完成。
-DocType: Accounts Settings,Credit Controller,信用控制器
-DocType: Loan,Applicant Type,申請人類型
-DocType: Purchase Invoice,03-Deficiency in services,03-服務不足
-DocType: Healthcare Settings,Default Medical Code Standard,默認醫療代碼標準
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +267,Purchase Receipt {0} is not submitted,採購入庫單{0}未提交
-DocType: Company,Default Payable Account,預設應付帳款科目
-apps/erpnext/erpnext/config/website.py +17,"Settings for online shopping cart such as shipping rules, price list etc.",設定線上購物車，如航運規則，價格表等
-apps/erpnext/erpnext/controllers/website_list_for_contact.py +113,{0}% Billed,{0}％已開立帳單
-apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +73,Reserved Qty,保留數量
-DocType: Party Account,Party Account,參與者科目
-apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py +142,Please select Company and Designation,請選擇公司和指定
-apps/erpnext/erpnext/config/setup.py +116,Human Resources,人力資源
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17,Reject,拒絕
-DocType: Journal Entry Account,Debit in Company Currency,借記卡在公司貨幣
-DocType: BOM Item,BOM Item,BOM項目
-DocType: Appraisal,For Employee,對於員工
-apps/erpnext/erpnext/hr/doctype/loan/loan.js +69,Make Disbursement Entry,請輸入支付
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +170,Row {0}: Advance against Supplier must be debit,行{0}：提前對供應商必須扣除
-DocType: Company,Default Values,默認值
-DocType: Expense Claim,Total Amount Reimbursed,報銷金額合計
-apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5,This is based on logs against this Vehicle. See timeline below for details,這是基於對本車輛的日誌。詳情請參閱以下時間表
-apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py +21,Payroll date can not be less than employee's joining date,工資日期不能低於員工的加入日期
-apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.py +87,{0} {1} created,已創建{0} {1}
-apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +46,"Job Openings for designation {0} already open \
+Import Successful!,導入成功！
+Payment Request already exists {0},付款申請已經存在{0}
+Cost of Issued Items,發布項目成本
+Hospital,醫院
+Quantity must not be more than {0},數量必須不超過{0}
+Funded Amount,資助金額
+Previous Financial Year is not closed,上一財政年度未關閉
+Practitioner Schedule,從業者時間表
+Age (Days),時間（天）
+Additional Salary,額外的薪水
+Quotation Item,產品報價
+Customer POS Id,客戶POS ID,
+Account Name,帳戶名稱
+From Date cannot be greater than To Date,起始日期不能大於結束日期
+Serial No {0} quantity {1} cannot be a fraction,序列號{0}的數量量{1}不能是分數
+Please enter Woocommerce Server URL,請輸入Woocommerce服務器網址
+Supplier Part Number,供應商零件編號
+Conversion rate cannot be 0 or 1,轉化率不能為0或1,
+All the mandatory Task for employee creation hasn't been done yet.,所有員工創建的強制性任務尚未完成。
+Credit Controller,信用控制器
+Applicant Type,申請人類型
+03-Deficiency in services,03-服務不足
+Default Medical Code Standard,默認醫療代碼標準
+Purchase Receipt {0} is not submitted,採購入庫單{0}未提交
+Default Payable Account,預設應付帳款科目
+"Settings for online shopping cart such as shipping rules, price list etc.",設定線上購物車，如航運規則，價格表等
+{0}% Billed,{0}％已開立帳單
+Reserved Qty,保留數量
+Party Account,參與者科目
+Please select Company and Designation,請選擇公司和指定
+Human Resources,人力資源
+Reject,拒絕
+Debit in Company Currency,借記卡在公司貨幣
+BOM Item,BOM項目
+For Employee,對於員工
+Make Disbursement Entry,請輸入支付
+Row {0}: Advance against Supplier must be debit,行{0}：提前對供應商必須扣除
+Default Values,默認值
+Total Amount Reimbursed,報銷金額合計
+This is based on logs against this Vehicle. See timeline below for details,這是基於對本車輛的日誌。詳情請參閱以下時間表
+Payroll date can not be less than employee's joining date,工資日期不能低於員工的加入日期
+{0} {1} created,已創建{0} {1}
+"Job Openings for designation {0} already open \
 					or hiring completed as per Staffing Plan {1}",指定{0}的職位空缺已根據人員配置計劃{1}已打開或正在招聘
-DocType: Vital Signs,Constipated,大便乾燥
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118,Against Supplier Invoice {0} dated {1},對供應商發票{0}日期{1}
-DocType: Customer,Default Price List,預設價格表
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +492,Asset Movement record {0} created,資產運動記錄{0}創建
-apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +175,No items found.,未找到任何項目。
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,您不能刪除會計年度{0}。會計年度{0}設置為默認的全局設置
-DocType: Share Transfer,Equity/Liability Account,庫存/負債科目
-apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,A customer with the same name already exists,一個同名的客戶已經存在
-DocType: Contract,Inactive,待用
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +224,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,這將提交工資單，並創建權責發生製日記賬分錄。你想繼續嗎？
-DocType: Purchase Invoice,Total Net Weight,總淨重
-DocType: Purchase Order,Order Confirmation No,訂單確認號
-DocType: Purchase Invoice,Eligibility For ITC,適用於ITC的資格
-DocType: Journal Entry,Entry Type,條目類型
-,Customer Credit Balance,客戶信用平衡
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +82,Net Change in Accounts Payable,應付帳款淨額變化
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +257,Credit limit has been crossed for customer {0} ({1}/{2}),客戶{0}（{1} / {2}）的信用額度已超過
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',需要' Customerwise折扣“客戶
-apps/erpnext/erpnext/config/accounts.py +136,Update bank payment dates with journals.,更新與日記帳之銀行付款日期。
-apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +26,Pricing,價錢
-DocType: Quotation,Term Details,長期詳情
-DocType: Employee Incentive,Employee Incentive,員工激勵
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,不能註冊超過{0}學生該學生群體更多。
-apps/erpnext/erpnext/templates/print_formats/includes/total.html +4,Total (Without Tax),總計（不含稅）
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,鉛計數
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,鉛計數
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +42,Stock Available,現貨供應
-DocType: Manufacturing Settings,Capacity Planning For (Days),產能規劃的範圍（天）
-apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10,Procurement,採購
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +67,None of the items have any change in quantity or value.,沒有一個項目無論在數量或價值的任何變化。
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +22,Mandatory field - Program,強制性領域 - 計劃
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +22,Mandatory field - Program,強制性領域 - 計劃
-DocType: Special Test Template,Result Component,結果組件
-apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46,Warranty Claim,保修索賠
-,Lead Details,潛在客戶詳情
-DocType: Salary Slip,Loan repayment,償還借款
-DocType: Share Transfer,Asset Account,資產科目
-DocType: Purchase Invoice,End date of current invoice's period,當前發票的期限的最後一天
-DocType: Pricing Rule,Applicable For,適用
-DocType: Lab Test,Technician Name,技術員姓名
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +425,"Cannot ensure delivery by Serial No as \
+Constipated,大便乾燥
+Against Supplier Invoice {0} dated {1},對供應商發票{0}日期{1}
+Default Price List,預設價格表
+Asset Movement record {0} created,資產運動記錄{0}創建
+No items found.,未找到任何項目。
+You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,您不能刪除會計年度{0}。會計年度{0}設置為默認的全局設置
+Equity/Liability Account,庫存/負債科目
+A customer with the same name already exists,一個同名的客戶已經存在
+Inactive,待用
+This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,這將提交工資單，並創建權責發生製日記賬分錄。你想繼續嗎？
+Total Net Weight,總淨重
+Order Confirmation No,訂單確認號
+Eligibility For ITC,適用於ITC的資格
+Entry Type,條目類型
+Customer Credit Balance,客戶信用平衡
+Net Change in Accounts Payable,應付帳款淨額變化
+Credit limit has been crossed for customer {0} ({1}/{2}),客戶{0}（{1} / {2}）的信用額度已超過
+Customer required for 'Customerwise Discount',需要' Customerwise折扣“客戶
+Update bank payment dates with journals.,更新與日記帳之銀行付款日期。
+Pricing,價錢
+Term Details,長期詳情
+Employee Incentive,員工激勵
+Cannot enroll more than {0} students for this student group.,不能註冊超過{0}學生該學生群體更多。
+Total (Without Tax),總計（不含稅）
+Lead Count,鉛計數
+Lead Count,鉛計數
+Stock Available,現貨供應
+Capacity Planning For (Days),產能規劃的範圍（天）
+Procurement,採購
+None of the items have any change in quantity or value.,沒有一個項目無論在數量或價值的任何變化。
+Mandatory field - Program,強制性領域 - 計劃
+Mandatory field - Program,強制性領域 - 計劃
+Result Component,結果組件
+Warranty Claim,保修索賠
+Lead Details,潛在客戶詳情
+Loan repayment,償還借款
+Asset Account,資產科目
+End date of current invoice's period,當前發票的期限的最後一天
+Applicable For,適用
+Technician Name,技術員姓名
+"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
 					Serial No.",無法通過序列號確保交貨，因為\項目{0}是否添加了確保交貨\序列號
-DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,取消鏈接在發票上的取消付款
-apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},進入當前的里程表讀數應該比最初的車輛里程表更大的{0}
-DocType: Restaurant Reservation,No Show,沒有出現
-DocType: Shipping Rule Country,Shipping Rule Country,航運規則國家
-apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10,Leave and Attendance,假離和缺勤
-DocType: Asset,Comprehensive Insurance,綜合保險
-apps/erpnext/erpnext/selling/doctype/customer/customer.js +118,Loyalty Point: {0},忠誠度積分：{0}
-apps/erpnext/erpnext/public/js/event.js +15,Add Leads,添加潛在客戶
-DocType: Leave Type,Include holidays within leaves as leaves,休假中包含節日做休假
-DocType: Loyalty Program,Redemption,贖回
-DocType: Sales Invoice,Packed Items,盒裝項目
-DocType: Tax Withholding Category,Tax Withholding Rates,預扣稅率
-apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,針對序列號保修索賠
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +237,'Total','總數'
-DocType: Loyalty Program,Collection Tier,收集層
-apps/erpnext/erpnext/hr/utils.py +156,From date can not be less than employee's joining date,起始日期不得少於員工的加入日期
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,"Advance paid against {0} {1} cannot be greater \
+Unlink Payment on Cancellation of Invoice,取消鏈接在發票上的取消付款
+Current Odometer reading entered should be greater than initial Vehicle Odometer {0},進入當前的里程表讀數應該比最初的車輛里程表更大的{0}
+No Show,沒有出現
+Shipping Rule Country,航運規則國家
+Leave and Attendance,假離和缺勤
+Comprehensive Insurance,綜合保險
+Loyalty Point: {0},忠誠度積分：{0}
+Add Leads,添加潛在客戶
+Include holidays within leaves as leaves,休假中包含節日做休假
+Redemption,贖回
+Packed Items,盒裝項目
+Tax Withholding Rates,預扣稅率
+Warranty Claim against Serial No.,針對序列號保修索賠
+'Total','總數'
+Collection Tier,收集層
+From date can not be less than employee's joining date,起始日期不得少於員工的加入日期
+"Advance paid against {0} {1} cannot be greater \
 						than Grand Total {2}",推動打擊{0} {1}不能大於付出\超過總計{2}
-DocType: Patient,Medication,藥物治療
-DocType: Production Plan,Include Non Stock Items,包括非庫存項目
-DocType: Project Update,Challenging/Slow,具有挑戰性/慢
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147,Please select item code,請選擇商品代碼
-DocType: Student Sibling,Studying in Same Institute,就讀於同一研究所
-DocType: Leave Type,Earned Leave,獲得休假
-DocType: Employee,Salary Details,薪資明細
-DocType: Territory,Territory Manager,區域經理
-DocType: Packed Item,To Warehouse (Optional),倉庫（可選）
-DocType: GST Settings,GST Accounts,GST科目
-DocType: Payment Entry,Paid Amount (Company Currency),支付的金額（公司貨幣）
-DocType: Purchase Invoice,Additional Discount,更多優惠
-DocType: Selling Settings,Selling Settings,銷售設置
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39,Online Auctions,網上拍賣
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +101,Please specify either Quantity or Valuation Rate or both,請註明無論是數量或估價率或兩者
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18,Fulfillment,履行
-apps/erpnext/erpnext/templates/generators/item.html +101,View in Cart,查看你的購物車
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Marketing Expenses,市場推廣開支
-,Item Shortage Report,商品短缺報告
-apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py +15,Can't create standard criteria. Please rename the criteria,無法創建標準條件。請重命名標準
-apps/erpnext/erpnext/stock/doctype/item/item.js +366,"Weight is mentioned,\nPlease mention ""Weight UOM"" too",重量被提及，請同時註明“重量計量單位”
-DocType: Stock Entry Detail,Material Request used to make this Stock Entry,做此存貨分錄所需之物料需求
-DocType: Hub User,Hub Password,集線器密碼
-DocType: Student Group Creation Tool,Separate course based Group for every Batch,為每個批次分離基於課程的組
-DocType: Student Group Creation Tool,Separate course based Group for every Batch,為每個批次分離基於課程的組
-apps/erpnext/erpnext/config/support.py +32,Single unit of an Item.,該產品的一個單元。
-DocType: Fee Category,Fee Category,收費類別
-DocType: Agriculture Task,Next Business Day,下一個營業日
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +3,Allocated Leaves,分配的葉子
-DocType: Drug Prescription,Dosage by time interval,劑量按時間間隔
-DocType: Cash Flow Mapper,Section Header,章節標題
-,Student Fee Collection,學生費徵收
-apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +24,Appointment Duration (mins),預約時間（分鐘）
-DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,為每股份轉移做會計分錄
-DocType: Leave Allocation,Total Leaves Allocated,已安排的休假總計
-apps/erpnext/erpnext/public/js/setup_wizard.js +178,Please enter valid Financial Year Start and End Dates,請輸入有效的財政年度開始和結束日期
-DocType: Employee,Date Of Retirement,退休日
-DocType: Upload Attendance,Get Template,獲取模板
-,Sales Person Commission Summary,銷售人員委員會摘要
-DocType: Additional Salary Component,Additional Salary Component,額外的薪資組件
-DocType: Material Request,Transferred,轉入
-DocType: Vehicle,Doors,門
-apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +118,ERPNext Setup Complete!,ERPNext設定完成！
-DocType: Healthcare Settings,Collect Fee for Patient Registration,收取病人登記費
-apps/erpnext/erpnext/stock/doctype/item/item.py +737,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,庫存交易後不能更改屬性。創建一個新項目並將庫存轉移到新項目
-DocType: Course Assessment Criteria,Weightage,權重
-DocType: Purchase Invoice,Tax Breakup,稅收分解
-DocType: Employee,Joining Details,加入詳情
-DocType: Member,Non Profit Member,非盈利會員
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67,{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,{0} {1}：需要的損益“科目成本中心{2}。請設置為公司默認的成本中心。
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +175,A Customer Group exists with same name please change the Customer name or rename the Customer Group,客戶群組存在相同名稱，請更改客戶名稱或重新命名客戶群組
-DocType: Location,Area,區
-apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,新建聯絡人
-DocType: Company,Company Description,公司介紹
-DocType: Territory,Parent Territory,家長領地
-DocType: Purchase Invoice,Place of Supply,供貨地點
-DocType: Quality Inspection Reading,Reading 2,閱讀2
-apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +101,Employee {0} already submited an apllication {1} for the payroll period {2},員工{0}已經在工資期間{2}提交了申請{1}
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +891,Material Receipt,收料
-DocType: Bank Statement Transaction Entry,Submit/Reconcile Payments,提交/協調付款
-DocType: Homepage,Products,產品
-DocType: Announcement,Instructor,講師
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +102,Select Item (optional),選擇項目（可選）
-apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py +103,The Loyalty Program isn't valid for the selected company,忠誠度計劃對所選公司無效
-DocType: Fee Schedule Student Group,Fee Schedule Student Group,費用計劃學生組
-DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.",如果此項目已變種，那麼它不能在銷售訂單等選擇
-DocType: Lead,Next Contact By,下一個聯絡人由
-DocType: Compensatory Leave Request,Compensatory Leave Request,補償請假
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +339,Quantity required for Item {0} in row {1},列{1}項目{0}必須有數量
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +46,Warehouse {0} can not be deleted as quantity exists for Item {1},倉庫{0} 不能被刪除因為項目{1}還有庫存
-DocType: Blanket Order,Order Type,訂單類型
-,Item-wise Sales Register,項目明智的銷售登記
-DocType: Asset,Gross Purchase Amount,總購買金額
-apps/erpnext/erpnext/utilities/user_progress.py +39,Opening Balances,期初餘額
-DocType: Asset,Depreciation Method,折舊方法
-DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,包括在基本速率此稅？
-apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Target,總目標
-DocType: Job Applicant,Applicant for a Job,申請人作業
-DocType: Production Plan Material Request,Production Plan Material Request,生產計劃申請材料
-DocType: Purchase Invoice,Release Date,發布日期
-DocType: Stock Reconciliation,Reconciliation JSON,JSON對賬
-apps/erpnext/erpnext/accounts/report/financial_statements.html +5,Too many columns. Export the report and print it using a spreadsheet application.,過多的列數。請導出報表，並使用試算表程式進行列印。
-DocType: Purchase Invoice Item,Batch No,批號
-DocType: Marketplace Settings,Hub Seller Name,集線器賣家名稱
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +27,Employee Advances,員工發展
-DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,允許多個銷售訂單對客戶的採購訂單
-DocType: Student Group Instructor,Student Group Instructor,學生組教練
-DocType: Student Group Instructor,Student Group Instructor,學生組教練
-DocType: Grant Application,Assessment  Mark (Out of 10),評估標記（滿分10分）
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Guardian2手機號碼
-apps/erpnext/erpnext/setup/doctype/company/company.py +263,Main,主頁
-apps/erpnext/erpnext/controllers/buying_controller.py +774,Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,項目{0}之後未標記為{1}項目。您可以從項目主文件中將它們作為{1}項啟用
-apps/erpnext/erpnext/stock/doctype/item/item.js +74,Variant,變種
-apps/erpnext/erpnext/controllers/status_updater.py +163,"For an item {0}, quantity must be negative number",對於商品{0}，數量必須是負數
-DocType: Naming Series,Set prefix for numbering series on your transactions,為你的交易編號序列設置的前綴
-DocType: Employee Attendance Tool,Employees HTML,員工HTML
-apps/erpnext/erpnext/stock/doctype/item/item.py +489,Default BOM ({0}) must be active for this item or its template,預設BOM（{0}）必須是活動的這個項目或者其模板
-DocType: Employee,Leave Encashed?,離開兌現？
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,機會從字段是強制性的
-DocType: Item,Variants,變種
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1309,Make Purchase Order,製作採購訂單
-DocType: SMS Center,Send To,發送到
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +201,There is not enough leave balance for Leave Type {0},沒有足夠的餘額休假請假類型{0}
-DocType: Payment Reconciliation Payment,Allocated amount,分配量
-DocType: Sales Team,Contribution to Net Total,貢獻淨合計
-DocType: Sales Invoice Item,Customer's Item Code,客戶的產品編號
-DocType: Stock Reconciliation,Stock Reconciliation,庫存調整
-DocType: Territory,Territory Name,地區名稱
-DocType: Email Digest,Purchase Orders to Receive,要收貨的採購訂單
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +197,Work-in-Progress Warehouse is required before Submit,提交之前，需要填入在製品倉庫
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +71,You can only have Plans with the same billing cycle in a Subscription,您只能在訂閱中擁有相同結算週期的計劃
-DocType: Bank Statement Transaction Settings Item,Mapped Data,映射數據
-DocType: Purchase Order Item,Warehouse and Reference,倉庫及參考
-DocType: Payroll Period Date,Payroll Period Date,工資期間日期
-DocType: Supplier,Statutory info and other general information about your Supplier,供應商的法定資訊和其他一般資料
-DocType: Item,Serial Nos and Batches,序列號和批號
-DocType: Item,Serial Nos and Batches,序列號和批號
-apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,學生群體力量
-apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,學生群體力量
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +262,Against Journal Entry {0} does not have any unmatched {1} entry,對日記條目{0}沒有任何無與倫比{1}進入
-apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py +113,"Subsidiary companies have already planned for {1} vacancies at a budget of {2}. \
+Medication,藥物治療
+Include Non Stock Items,包括非庫存項目
+Challenging/Slow,具有挑戰性/慢
+Please select item code,請選擇商品代碼
+Studying in Same Institute,就讀於同一研究所
+Earned Leave,獲得休假
+Salary Details,薪資明細
+Territory Manager,區域經理
+To Warehouse (Optional),倉庫（可選）
+GST Accounts,GST科目
+Paid Amount (Company Currency),支付的金額（公司貨幣）
+Additional Discount,更多優惠
+Selling Settings,銷售設置
+Online Auctions,網上拍賣
+Please specify either Quantity or Valuation Rate or both,請註明無論是數量或估價率或兩者
+Fulfillment,履行
+View in Cart,查看你的購物車
+Marketing Expenses,市場推廣開支
+Item Shortage Report,商品短缺報告
+Can't create standard criteria. Please rename the criteria,無法創建標準條件。請重命名標準
+"Weight is mentioned,\nPlease mention ""Weight UOM"" too",重量被提及，請同時註明“重量計量單位”
+Material Request used to make this Stock Entry,做此存貨分錄所需之物料需求
+Hub Password,集線器密碼
+Separate course based Group for every Batch,為每個批次分離基於課程的組
+Separate course based Group for every Batch,為每個批次分離基於課程的組
+Single unit of an Item.,該產品的一個單元。
+Fee Category,收費類別
+Next Business Day,下一個營業日
+Allocated Leaves,分配的葉子
+Dosage by time interval,劑量按時間間隔
+Section Header,章節標題
+Student Fee Collection,學生費徵收
+Appointment Duration (mins),預約時間（分鐘）
+Make Accounting Entry For Every Stock Movement,為每股份轉移做會計分錄
+Total Leaves Allocated,已安排的休假總計
+Please enter valid Financial Year Start and End Dates,請輸入有效的財政年度開始和結束日期
+Date Of Retirement,退休日
+Get Template,獲取模板
+Sales Person Commission Summary,銷售人員委員會摘要
+Additional Salary Component,額外的薪資組件
+Transferred,轉入
+Doors,門
+ERPNext Setup Complete!,ERPNext設定完成！
+Collect Fee for Patient Registration,收取病人登記費
+Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,庫存交易後不能更改屬性。創建一個新項目並將庫存轉移到新項目
+Weightage,權重
+Tax Breakup,稅收分解
+Joining Details,加入詳情
+Non Profit Member,非盈利會員
+{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,{0} {1}：需要的損益“科目成本中心{2}。請設置為公司默認的成本中心。
+A Customer Group exists with same name please change the Customer name or rename the Customer Group,客戶群組存在相同名稱，請更改客戶名稱或重新命名客戶群組
+Area,區
+New Contact,新建聯絡人
+Company Description,公司介紹
+Parent Territory,家長領地
+Place of Supply,供貨地點
+Reading 2,閱讀2,
+Employee {0} already submited an apllication {1} for the payroll period {2},員工{0}已經在工資期間{2}提交了申請{1}
+Material Receipt,收料
+Submit/Reconcile Payments,提交/協調付款
+Products,產品
+Instructor,講師
+Select Item (optional),選擇項目（可選）
+The Loyalty Program isn't valid for the selected company,忠誠度計劃對所選公司無效
+Fee Schedule Student Group,費用計劃學生組
+"If this item has variants, then it cannot be selected in sales orders etc.",如果此項目已變種，那麼它不能在銷售訂單等選擇
+Next Contact By,下一個聯絡人由
+Compensatory Leave Request,補償請假
+Quantity required for Item {0} in row {1},列{1}項目{0}必須有數量
+Warehouse {0} can not be deleted as quantity exists for Item {1},倉庫{0} 不能被刪除因為項目{1}還有庫存
+Order Type,訂單類型
+Item-wise Sales Register,項目明智的銷售登記
+Gross Purchase Amount,總購買金額
+Opening Balances,期初餘額
+Depreciation Method,折舊方法
+Is this Tax included in Basic Rate?,包括在基本速率此稅？
+Total Target,總目標
+Applicant for a Job,申請人作業
+Production Plan Material Request,生產計劃申請材料
+Release Date,發布日期
+Reconciliation JSON,JSON對賬
+Too many columns. Export the report and print it using a spreadsheet application.,過多的列數。請導出報表，並使用試算表程式進行列印。
+Batch No,批號
+Hub Seller Name,集線器賣家名稱
+Employee Advances,員工發展
+Allow multiple Sales Orders against a Customer's Purchase Order,允許多個銷售訂單對客戶的採購訂單
+Student Group Instructor,學生組教練
+Student Group Instructor,學生組教練
+Assessment  Mark (Out of 10),評估標記（滿分10分）
+Guardian2 Mobile No,Guardian2手機號碼
+Main,主頁
+Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,項目{0}之後未標記為{1}項目。您可以從項目主文件中將它們作為{1}項啟用
+Variant,變種
+"For an item {0}, quantity must be negative number",對於商品{0}，數量必須是負數
+Set prefix for numbering series on your transactions,為你的交易編號序列設置的前綴
+Employees HTML,員工HTML,
+Default BOM ({0}) must be active for this item or its template,預設BOM（{0}）必須是活動的這個項目或者其模板
+Leave Encashed?,離開兌現？
+Opportunity From field is mandatory,機會從字段是強制性的
+Variants,變種
+Make Purchase Order,製作採購訂單
+Send To,發送到
+There is not enough leave balance for Leave Type {0},沒有足夠的餘額休假請假類型{0}
+Allocated amount,分配量
+Contribution to Net Total,貢獻淨合計
+Customer's Item Code,客戶的產品編號
+Stock Reconciliation,庫存調整
+Territory Name,地區名稱
+Purchase Orders to Receive,要收貨的採購訂單
+Work-in-Progress Warehouse is required before Submit,提交之前，需要填入在製品倉庫
+You can only have Plans with the same billing cycle in a Subscription,您只能在訂閱中擁有相同結算週期的計劃
+Mapped Data,映射數據
+Warehouse and Reference,倉庫及參考
+Payroll Period Date,工資期間日期
+Statutory info and other general information about your Supplier,供應商的法定資訊和其他一般資料
+Serial Nos and Batches,序列號和批號
+Serial Nos and Batches,序列號和批號
+Student Group Strength,學生群體力量
+Student Group Strength,學生群體力量
+Against Journal Entry {0} does not have any unmatched {1} entry,對日記條目{0}沒有任何無與倫比{1}進入
+"Subsidiary companies have already planned for {1} vacancies at a budget of {2}. \
 				Staffing Plan for {0} should allocate more vacancies and budget for {3} than planned for its subsidiary companies",子公司已經計劃{2}的預算{1}空缺。 \ {0}的人員配備計劃應為其子公司分配更多空缺和預算{3}
-apps/erpnext/erpnext/config/hr.py +166,Appraisals,估價
-apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8,Training Events,培訓活動
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +210,Duplicate Serial No entered for Item {0},重複的序列號輸入的項目{0}
-apps/erpnext/erpnext/config/selling.py +179,Track Leads by Lead Source.,通過鉛源追踪潛在客戶。
-DocType: Shipping Rule Condition,A condition for a Shipping Rule,為運輸規則的條件
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +182,Please enter ,請輸入
-apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +64,Maintenance Log,維護日誌
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +256,Please set filter based on Item or Warehouse,根據項目或倉庫請設置過濾器
-DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),淨重這個包。 （當項目的淨重量總和自動計算）
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +43,Make Inter Company Journal Entry,使公司日記帳分錄
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +901,Discount amount cannot be greater than 100%,折扣金額不能大於100％
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +26,"Number of new Cost Center, it will be included in the cost center name as a prefix",新成本中心的數量，它將作為前綴包含在成本中心名稱中
-DocType: Sales Order,To Deliver and Bill,準備交貨及開立發票
-DocType: Student Group,Instructors,教師
-DocType: GL Entry,Credit Amount in Account Currency,在科目幣金額
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +631,BOM {0} must be submitted,BOM {0}必須提交
-DocType: Authorization Control,Authorization Control,授權控制
-apps/erpnext/erpnext/controllers/buying_controller.py +416,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},行＃{0}：拒絕倉庫是強制性的反對否決項{1}
-apps/erpnext/erpnext/controllers/stock_controller.py +96,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.",倉庫{0}未與任何科目關聯，請在倉庫記錄中設定科目，或在公司{1}中設置默認庫存科目。
-apps/erpnext/erpnext/utilities/activation.py +81,Manage your orders,管理您的訂單
-DocType: Work Order Operation,Actual Time and Cost,實際時間和成本
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +57,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},針對銷售訂單{2}的項目{1}，最多可以有 {0} 被完成。
-DocType: Crop,Crop Spacing,作物間距
-DocType: Course,Course Abbreviation,當然縮寫
-DocType: Budget,Action if Annual Budget Exceeded on PO,年度預算超出採購訂單時採取的行動
-DocType: Student Leave Application,Student Leave Application,學生請假申請
-DocType: Item,Will also apply for variants,同時將申請變種
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +297,"Asset cannot be cancelled, as it is already {0}",資產不能被取消，因為它已經是{0}
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +31,Employee {0} on Half day on {1},員工{0}上半天{1}
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +59,Total working hours should not be greater than max working hours {0},總的工作時間不應超過最高工時更大{0}
-apps/erpnext/erpnext/templates/pages/task_info.html +90,On,開啟
-apps/erpnext/erpnext/config/selling.py +62,Bundle items at time of sale.,在銷售時捆綁項目。
-DocType: Delivery Settings,Dispatch Settings,發貨設置
-DocType: Material Request Plan Item,Actual Qty,實際數量
-DocType: Sales Invoice Item,References,參考
-DocType: Quality Inspection Reading,Reading 10,閱讀10
-apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +48,Serial nos {0} does not belongs to the location {1},序列號{0}不屬於位置{1}
-DocType: Item,Barcodes,條形碼
-DocType: Hub Tracked Item,Hub Node,樞紐節點
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,您輸入重複的項目。請糾正，然後再試一次。
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92,Associate,關聯
-DocType: Asset Movement,Asset Movement,資產運動
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +605,Work Order {0} must be submitted,必須提交工單{0}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2227,New Cart,新的車
-DocType: Taxable Salary Slab,From Amount,從金額
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,項{0}不是一個序列化的項目
-DocType: Leave Type,Encashment,兌現
-DocType: Delivery Settings,Delivery Settings,交貨設置
-apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js +50,Fetch Data,獲取數據
-apps/erpnext/erpnext/hr/doctype/leave_policy/leave_policy.py +16,Maximum leave allowed in the leave type {0} is {1},假期類型{0}允許的最大休假是{1}
-DocType: SMS Center,Create Receiver List,創建接收器列表
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +98,Available-for-use Date should be after purchase date,可供使用的日期應在購買日期之後
-DocType: Vehicle,Wheels,車輪
-DocType: Packing Slip,To Package No.,以包號
-DocType: Sales Invoice Item,Deferred Revenue Account,遞延收入科目
-DocType: Production Plan,Material Requests,材料要求
-DocType: Warranty Claim,Issue Date,發行日期
-DocType: Activity Cost,Activity Cost,項目成本
-DocType: Sales Invoice Timesheet,Timesheet Detail,詳細時間表
-DocType: Purchase Receipt Item Supplied,Consumed Qty,消耗的數量
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52,Telecommunications,電信
-apps/erpnext/erpnext/accounts/party.py +292,Billing currency must be equal to either default company's currency or party account currency,帳單貨幣必須等於默認公司的貨幣或科目幣種
-DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),表示該包是這個交付的一部分（僅草案）
-apps/erpnext/erpnext/controllers/accounts_controller.py +786,Row {0}: Due Date cannot be before posting date,行{0}：到期日期不能在發布日期之前
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +37,Make Payment Entry,製作付款分錄
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129,Quantity for Item {0} must be less than {1},項目{0}的數量必須小於{1}
-,Sales Invoice Trends,銷售發票趨勢
-DocType: Leave Application,Apply / Approve Leaves,申請/審批葉
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +180,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',可以參考的行只有在充電類型是“在上一行量'或'前行總計”
-DocType: Sales Order Item,Delivery Warehouse,交貨倉庫
-DocType: Leave Type,Earned Leave Frequency,獲得休假頻率
-apps/erpnext/erpnext/config/accounts.py +209,Tree of financial Cost Centers.,財務成本中心的樹。
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +151,Sub Type,子類型
-DocType: Serial No,Delivery Document No,交貨證明文件號碼
-DocType: Sales Order Item,Ensure Delivery Based on Produced Serial No,確保基於生產的序列號的交貨
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +197,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},請公司制定“關於資產處置收益/損失科目”{0}
-DocType: Landed Cost Voucher,Get Items From Purchase Receipts,從採購入庫單取得項目
-DocType: Serial No,Creation Date,創建日期
-apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +55,Target Location is required for the asset {0},目標位置是資產{0}所必需的
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +42,"Selling must be checked, if Applicable For is selected as {0}",銷售必須進行檢查，如果適用於被選擇為{0}
-DocType: Production Plan Material Request,Material Request Date,材料申請日期
-DocType: Purchase Order Item,Supplier Quotation Item,供應商報價項目
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +208,Material Consumption is not set in Manufacturing Settings.,材料消耗未在生產設置中設置。
-apps/erpnext/erpnext/templates/pages/help.html +46,Visit the forums,訪問論壇
-DocType: Student,Student Mobile Number,學生手機號碼
-DocType: Item,Has Variants,有變種
-DocType: Employee Benefit Claim,Claim Benefit For,索賠利益
-apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,更新響應
-apps/erpnext/erpnext/public/js/utils.js +538,You have already selected items from {0} {1},您已經選擇從項目{0} {1}
-DocType: Monthly Distribution,Name of the Monthly Distribution,每月分配的名稱
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +100,Batch ID is mandatory,批號是必需的
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +100,Batch ID is mandatory,批號是必需的
-DocType: Sales Person,Parent Sales Person,母公司銷售人員
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +102,No items to be received are overdue,沒有收到的物品已逾期
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +101,The seller and the buyer cannot be the same,賣方和買方不能相同
-DocType: Project,Collect Progress,收集進度
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24,Select the program first,首先選擇程序
-DocType: Patient Appointment,Patient Age,患者年齡
-apps/erpnext/erpnext/config/learn.py +253,Managing Projects,項目管理
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +229,Serial no {0} has been already returned,序列號{0}已被返回
-DocType: Supplier,Supplier of Goods or Services.,供應商的商品或服務。
-DocType: Budget,Fiscal Year,財政年度
-DocType: Asset Maintenance Log,Planned,計劃
-apps/erpnext/erpnext/hr/utils.py +199,A {0} exists between {1} and {2} (,{1}和{2}之間存在{0}（
-DocType: Vehicle Log,Fuel Price,燃油價格
-DocType: Bank Guarantee,Margin Money,保證金
-DocType: Budget,Budget,預算
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +83,Set Open,設置打開
-apps/erpnext/erpnext/stock/doctype/item/item.py +287,Fixed Asset Item must be a non-stock item.,固定資產項目必須是一個非庫存項目。
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +60,"Budget cannot be assigned against {0}, as it's not an Income or Expense account",財政預算案不能對{0}指定的，因為它不是一個收入或支出科目
-apps/erpnext/erpnext/hr/utils.py +228,Max exemption amount for {0} is {1},{0}的最大免除金額為{1}
-apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,已實現
-DocType: Student Admission,Application Form Route,申請表路線
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +58,Leave Type {0} cannot be allocated since it is leave without pay,休假類型{0}，因為它是停薪留職無法分配
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +167,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},行{0}：已分配量{1}必須小於或等於發票餘額{2}
-DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,銷售發票一被儲存，就會顯示出來。
-DocType: Lead,Follow Up,跟進
-DocType: Item,Is Sales Item,是銷售項目
-apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +55,Item Group Tree,項目群組的樹狀結構
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +73,Item {0} is not setup for Serial Nos. Check Item master,項目{0}的序列號未設定，請檢查項目主檔
-DocType: Maintenance Visit,Maintenance Time,維護時間
-,Amount to Deliver,量交付
-DocType: Asset,Insurance Start Date,保險開始日期
-DocType: Salary Component,Flexible Benefits,靈活的好處
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +350,Same item has been entered multiple times. {0},相同的物品已被多次輸入。 {0}
-apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +30,The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,這個詞開始日期不能超過哪個術語鏈接學年的開學日期較早（學年{}）。請更正日期，然後再試一次。
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +201,There were errors.,有錯誤。
-apps/erpnext/erpnext/hr/doctype/shift_request/shift_request.py +68,Employee {0} has already applied for {1} between {2} and {3} : ,員工{0}已在{2}和{3}之間申請{1}：
-DocType: Guardian,Guardian Interests,守護興趣
-apps/erpnext/erpnext/accounts/doctype/account/account.js +45,Update Account Name / Number,更新帳戶名稱/號碼
-DocType: Naming Series,Current Value,當前值
-apps/erpnext/erpnext/controllers/accounts_controller.py +331,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,多個會計年度的日期{0}存在。請設置公司財年
-DocType: Education Settings,Instructor Records to be created by,導師記錄由
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229,{0} created,{0}已新增
-DocType: GST Account,GST Account,GST帳戶
-DocType: Delivery Note Item,Against Sales Order,對銷售訂單
-,Serial No Status,序列號狀態
-DocType: Payment Entry Reference,Outstanding,優秀
-,Daily Timesheet Summary,每日時間表摘要
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137,"Row {0}: To set {1} periodicity, difference between from and to date \
+Appraisals,估價
+Training Events,培訓活動
+Duplicate Serial No entered for Item {0},重複的序列號輸入的項目{0}
+Track Leads by Lead Source.,通過鉛源追踪潛在客戶。
+A condition for a Shipping Rule,為運輸規則的條件
+Please enter ,請輸入
+Maintenance Log,維護日誌
+Please set filter based on Item or Warehouse,根據項目或倉庫請設置過濾器
+The net weight of this package. (calculated automatically as sum of net weight of items),淨重這個包。 （當項目的淨重量總和自動計算）
+Make Inter Company Journal Entry,使公司日記帳分錄
+Discount amount cannot be greater than 100%,折扣金額不能大於100％
+"Number of new Cost Center, it will be included in the cost center name as a prefix",新成本中心的數量，它將作為前綴包含在成本中心名稱中
+To Deliver and Bill,準備交貨及開立發票
+Instructors,教師
+Credit Amount in Account Currency,在科目幣金額
+BOM {0} must be submitted,BOM {0}必須提交
+Authorization Control,授權控制
+Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},行＃{0}：拒絕倉庫是強制性的反對否決項{1}
+"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.",倉庫{0}未與任何科目關聯，請在倉庫記錄中設定科目，或在公司{1}中設置默認庫存科目。
+Manage your orders,管理您的訂單
+Actual Time and Cost,實際時間和成本
+Material Request of maximum {0} can be made for Item {1} against Sales Order {2},針對銷售訂單{2}的項目{1}，最多可以有 {0} 被完成。
+Crop Spacing,作物間距
+Course Abbreviation,當然縮寫
+Action if Annual Budget Exceeded on PO,年度預算超出採購訂單時採取的行動
+Student Leave Application,學生請假申請
+Will also apply for variants,同時將申請變種
+"Asset cannot be cancelled, as it is already {0}",資產不能被取消，因為它已經是{0}
+Employee {0} on Half day on {1},員工{0}上半天{1}
+Total working hours should not be greater than max working hours {0},總的工作時間不應超過最高工時更大{0}
+On,開啟
+Bundle items at time of sale.,在銷售時捆綁項目。
+Dispatch Settings,發貨設置
+Actual Qty,實際數量
+References,參考
+Reading 10,閱讀10,
+Serial nos {0} does not belongs to the location {1},序列號{0}不屬於位置{1}
+Barcodes,條形碼
+Hub Node,樞紐節點
+You have entered duplicate items. Please rectify and try again.,您輸入重複的項目。請糾正，然後再試一次。
+Associate,關聯
+Asset Movement,資產運動
+Work Order {0} must be submitted,必須提交工單{0}
+New Cart,新的車
+From Amount,從金額
+Item {0} is not a serialized Item,項{0}不是一個序列化的項目
+Encashment,兌現
+Delivery Settings,交貨設置
+Fetch Data,獲取數據
+Maximum leave allowed in the leave type {0} is {1},假期類型{0}允許的最大休假是{1}
+Create Receiver List,創建接收器列表
+Available-for-use Date should be after purchase date,可供使用的日期應在購買日期之後
+Wheels,車輪
+To Package No.,以包號
+Deferred Revenue Account,遞延收入科目
+Material Requests,材料要求
+Issue Date,發行日期
+Activity Cost,項目成本
+Timesheet Detail,詳細時間表
+Consumed Qty,消耗的數量
+Telecommunications,電信
+Billing currency must be equal to either default company's currency or party account currency,帳單貨幣必須等於默認公司的貨幣或科目幣種
+Indicates that the package is a part of this delivery (Only Draft),表示該包是這個交付的一部分（僅草案）
+Row {0}: Due Date cannot be before posting date,行{0}：到期日期不能在發布日期之前
+Make Payment Entry,製作付款分錄
+Quantity for Item {0} must be less than {1},項目{0}的數量必須小於{1}
+Sales Invoice Trends,銷售發票趨勢
+Apply / Approve Leaves,申請/審批葉
+Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',可以參考的行只有在充電類型是“在上一行量'或'前行總計”
+Delivery Warehouse,交貨倉庫
+Earned Leave Frequency,獲得休假頻率
+Tree of financial Cost Centers.,財務成本中心的樹。
+Sub Type,子類型
+Delivery Document No,交貨證明文件號碼
+Ensure Delivery Based on Produced Serial No,確保基於生產的序列號的交貨
+Please set 'Gain/Loss Account on Asset Disposal' in Company {0},請公司制定“關於資產處置收益/損失科目”{0}
+Get Items From Purchase Receipts,從採購入庫單取得項目
+Creation Date,創建日期
+Target Location is required for the asset {0},目標位置是資產{0}所必需的
+"Selling must be checked, if Applicable For is selected as {0}",銷售必須進行檢查，如果適用於被選擇為{0}
+Material Request Date,材料申請日期
+Supplier Quotation Item,供應商報價項目
+Material Consumption is not set in Manufacturing Settings.,材料消耗未在生產設置中設置。
+Visit the forums,訪問論壇
+Student Mobile Number,學生手機號碼
+Has Variants,有變種
+Claim Benefit For,索賠利益
+Update Response,更新響應
+You have already selected items from {0} {1},您已經選擇從項目{0} {1}
+Name of the Monthly Distribution,每月分配的名稱
+Batch ID is mandatory,批號是必需的
+Batch ID is mandatory,批號是必需的
+Parent Sales Person,母公司銷售人員
+No items to be received are overdue,沒有收到的物品已逾期
+The seller and the buyer cannot be the same,賣方和買方不能相同
+Collect Progress,收集進度
+Select the program first,首先選擇程序
+Patient Age,患者年齡
+Managing Projects,項目管理
+Serial no {0} has been already returned,序列號{0}已被返回
+Supplier of Goods or Services.,供應商的商品或服務。
+Fiscal Year,財政年度
+Planned,計劃
+A {0} exists between {1} and {2} (,{1}和{2}之間存在{0}（
+Fuel Price,燃油價格
+Margin Money,保證金
+Budget,預算
+Set Open,設置打開
+Fixed Asset Item must be a non-stock item.,固定資產項目必須是一個非庫存項目。
+"Budget cannot be assigned against {0}, as it's not an Income or Expense account",財政預算案不能對{0}指定的，因為它不是一個收入或支出科目
+Max exemption amount for {0} is {1},{0}的最大免除金額為{1}
+Achieved,已實現
+Application Form Route,申請表路線
+Leave Type {0} cannot be allocated since it is leave without pay,休假類型{0}，因為它是停薪留職無法分配
+Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},行{0}：已分配量{1}必須小於或等於發票餘額{2}
+In Words will be visible once you save the Sales Invoice.,銷售發票一被儲存，就會顯示出來。
+Follow Up,跟進
+Is Sales Item,是銷售項目
+Item Group Tree,項目群組的樹狀結構
+Item {0} is not setup for Serial Nos. Check Item master,項目{0}的序列號未設定，請檢查項目主檔
+Maintenance Time,維護時間
+Amount to Deliver,量交付
+Insurance Start Date,保險開始日期
+Flexible Benefits,靈活的好處
+Same item has been entered multiple times. {0},相同的物品已被多次輸入。 {0}
+The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,這個詞開始日期不能超過哪個術語鏈接學年的開學日期較早（學年{}）。請更正日期，然後再試一次。
+There were errors.,有錯誤。
+Employee {0} has already applied for {1} between {2} and {3} : ,員工{0}已在{2}和{3}之間申請{1}：
+Guardian Interests,守護興趣
+Update Account Name / Number,更新帳戶名稱/號碼
+Current Value,當前值
+Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,多個會計年度的日期{0}存在。請設置公司財年
+Instructor Records to be created by,導師記錄由
+{0} created,{0}已新增
+GST Account,GST帳戶
+Against Sales Order,對銷售訂單
+Serial No Status,序列號狀態
+Outstanding,優秀
+Daily Timesheet Summary,每日時間表摘要
+"Row {0}: To set {1} periodicity, difference between from and to date \
 						must be greater than or equal to {2}","行{0}：設置{1}的週期性，從和到日期\
 之間差必須大於或等於{2}"
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,這是基於庫存移動。見{0}詳情
-DocType: Pricing Rule,Selling,銷售
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +394,Amount {0} {1} deducted against {2},金額{0} {1}抵扣{2}
-DocType: Sales Person,Name and Employee ID,姓名和僱員ID
-DocType: Website Item Group,Website Item Group,網站項目群組
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +550,No salary slip found to submit for the above selected criteria OR salary slip already submitted,沒有發現提交上述選定標准或已提交工資單的工資單
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +160,Duties and Taxes,關稅和稅款
-DocType: Projects Settings,Projects Settings,項目設置
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +392,Please enter Reference date,參考日期請輸入
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44,{0} payment entries can not be filtered by {1},{0}付款分錄不能由{1}過濾
-DocType: Item Website Specification,Table for Item that will be shown in Web Site,表項，將在網站顯示出來
-DocType: Purchase Order Item Supplied,Supplied Qty,附送數量
-DocType: Purchase Order Item,Material Request Item,物料需求項目
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +303,Please cancel Purchase Receipt {0} first,請先取消購買收據{0}
-apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,項目群組樹。
-DocType: Production Plan,Total Produced Qty,總生產數量
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +190,Cannot refer row number greater than or equal to current row number for this Charge type,不能引用的行號大於或等於當前行號碼提供給充電式
-,Item-wise Purchase History,全部項目的購買歷史
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},請點擊“生成表”來獲取序列號增加了對項目{0}
-DocType: Account,Frozen,凍結的
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +382,Vehicle Type,車輛類型
-DocType: Sales Invoice Payment,Base Amount (Company Currency),基本金額（公司幣種）
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1002,Raw Materials,原料
-DocType: Installation Note,Installation Time,安裝時間
-DocType: Sales Invoice,Accounting Details,會計細節
-DocType: Shopify Settings,status html,狀態HTML
-apps/erpnext/erpnext/setup/doctype/company/company.js +133,Delete all the Transactions for this Company,刪除所有交易本公司
-DocType: Inpatient Record,O Positive,O積極
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72,Investments,投資
-DocType: Issue,Resolution Details,詳細解析
-apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py +170,Transaction Type,交易類型
-DocType: Item Quality Inspection Parameter,Acceptance Criteria,驗收標準
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159,Please enter Material Requests in the above table,請輸入在上表請求材料
-apps/erpnext/erpnext/hr/doctype/loan/loan.py +154,No repayments available for Journal Entry,沒有可用於日記帳分錄的還款
-DocType: Hub Tracked Item,Image List,圖像列表
-DocType: Item Attribute,Attribute Name,屬性名稱
-DocType: Subscription,Generate Invoice At Beginning Of Period,在期初生成發票
-DocType: BOM,Show In Website,顯示在網站
-DocType: Loan Application,Total Payable Amount,合計應付額
-DocType: Task,Expected Time (in hours),預期時間（以小時計）
-DocType: Item Reorder,Check in (group),檢查（組）
-,Qty to Order,訂購數量
-DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked",負債或權益下的科目頭，其中利潤/虧損將被黃牌警告
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +44,Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},對於財務年度{4}，{1}&#39;{2}&#39;和科目“{3}”已存在另一個預算記錄“{0}”
-apps/erpnext/erpnext/config/projects.py +36,Gantt chart of all tasks.,所有任務的甘特圖。
-DocType: Opportunity,Mins to First Response,分鐘為第一個反應
-DocType: Pricing Rule,Margin Type,保證金類型
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15,{0} hours,{0}小時
-DocType: Course,Default Grading Scale,默認等級規模
-DocType: Appraisal,For Employee Name,對於員工姓名
-DocType: Woocommerce Settings,Tax Account,稅收科目
-DocType: C-Form Invoice Detail,Invoice No,發票號碼
-DocType: Room,Room Name,房間名稱
-DocType: Prescription Duration,Prescription Duration,處方時間
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +115,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}",離開不能應用/前{0}取消，因為假平衡已經被搬入轉發在未來休假分配記錄{1}
-apps/erpnext/erpnext/config/selling.py +234,Customer Addresses And Contacts,客戶的地址和聯絡方式
-,Campaign Efficiency,運動效率
-,Campaign Efficiency,運動效率
-DocType: Discussion,Discussion,討論
-DocType: Payment Entry,Transaction ID,事務ID
-DocType: Payroll Entry,Deduct Tax For Unsubmitted Tax Exemption Proof,扣除未提交免稅證明的稅額
-DocType: Volunteer,Anytime,任何時候
-DocType: Bank Account,Bank Account No,銀行帳號
-DocType: Employee Tax Exemption Proof Submission,Employee Tax Exemption Proof Submission,員工免稅證明提交
-DocType: Patient,Surgical History,手術史
-DocType: Bank Statement Settings Item,Mapped Header,映射的標題
-DocType: Employee,Resignation Letter Date,辭退信日期
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,Pricing Rules are further filtered based on quantity.,定價規則進一步過濾基於數量。
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +417,Please set the Date Of Joining for employee {0},請為員工{0}設置加入日期
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +417,Please set the Date Of Joining for employee {0},請為員工{0}設置加入日期
-DocType: Inpatient Record,Discharge,卸貨
-DocType: Task,Total Billing Amount (via Time Sheet),總開票金額（通過時間表）
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,重複客戶收入
-DocType: Bank Statement Settings,Mapped Items,映射項目
-DocType: Amazon MWS Settings,IT,它
-DocType: Chapter,Chapter,章節
-apps/erpnext/erpnext/utilities/user_progress.py +146,Pair,對
-DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,選擇此模式後，默認帳戶將在POS發票中自動更新。
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1048,Select BOM and Qty for Production,選擇BOM和數量生產
-DocType: Asset,Depreciation Schedule,折舊計劃
-apps/erpnext/erpnext/config/selling.py +124,Sales Partner Addresses And Contacts,銷售合作夥伴地址和聯繫人
-DocType: Bank Reconciliation Detail,Against Account,針對帳戶
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +84,Half Day Date should be between From Date and To Date,半天時間應該是從之間的日期和終止日期
-DocType: Maintenance Schedule Detail,Actual Date,實際日期
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +135,Please set the Default Cost Center in {0} company.,請在{0}公司中設置默認成本中心。
-DocType: Item,Has Batch No,有批號
-DocType: Shopify Webhook Detail,Shopify Webhook Detail,Shopify Webhook詳細信息
-apps/erpnext/erpnext/config/accounts.py +479,Goods and Services Tax (GST India),商品和服務稅（印度消費稅）
-DocType: Delivery Note,Excise Page Number,消費頁碼
-DocType: Asset,Purchase Date,購買日期
-apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js +33,Could not generate Secret,無法生成秘密
-DocType: Volunteer,Volunteer Type,志願者類型
-DocType: Shift Assignment,Shift Type,班次類型
-DocType: Student,Personal Details,個人資料
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +199,Please set 'Asset Depreciation Cost Center' in Company {0},請設置在公司的資產折舊成本中心“{0}
-,Maintenance Schedules,保養時間表
-DocType: Task,Actual End Date (via Time Sheet),實際結束日期（通過時間表）
-DocType: Soil Texture,Soil Type,土壤類型
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +389,Amount {0} {1} against {2} {3},量{0} {1}對{2} {3}
-,Quotation Trends,報價趨勢
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +166,Item Group not mentioned in item master for item {0},項目{0}之項目主檔未提及之項目群組
-DocType: GoCardless Mandate,GoCardless Mandate,GoCardless任務
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +440,Debit To account must be a Receivable account,借方科目必須是應收帳款科目
-DocType: Shipping Rule,Shipping Amount,航運量
-DocType: Supplier Scorecard Period,Period Score,期間得分
-apps/erpnext/erpnext/public/js/event.js +19,Add Customers,添加客戶
-apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Pending Amount,待審核金額
-DocType: Lab Test Template,Special,特別
-DocType: Loyalty Program,Conversion Factor,轉換因子
-DocType: Purchase Order,Delivered,交付
-,Vehicle Expenses,車輛費用
-DocType: Healthcare Settings,Create Lab Test(s) on Sales Invoice Submit,在銷售發票上創建實驗室測試提交
-DocType: Serial No,Invoice Details,發票明細
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +72,Please enable Google Maps Settings to estimate and optimize routes,請啟用Google地圖設置以估算和優化路線
-DocType: Grant Application,Show on Website,在網站上顯示
-apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29,Start on,開始
-DocType: Hub Tracked Item,Hub Category,中心類別
-DocType: Purchase Receipt,Vehicle Number,車號
-DocType: Loan,Loan Amount,貸款額度
-DocType: Student Report Generation Tool,Add Letterhead,添加信頭
-DocType: Program Enrollment,Self-Driving Vehicle,自駕車
-DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,供應商記分卡站立
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +479,Row {0}: Bill of Materials not found for the Item {1},行{0}：材料清單未找到項目{1}
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +112,Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,共分配葉{0}不能小於已經批准葉{1}期間
-DocType: Journal Entry,Accounts Receivable,應收帳款
-,Supplier-Wise Sales Analytics,供應商相關的銷售分析
-DocType: Purchase Invoice,Availed ITC Central Tax,有效的ITC中央稅收
-DocType: Sales Invoice,Company Address Name,公司地址名稱
-DocType: Work Order,Use Multi-Level BOM,採用多級物料清單
-DocType: Bank Reconciliation,Include Reconciled Entries,包括對賬項目
-DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)",家長課程（如果不是家長課程的一部分，請留空）
-DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)",家長課程（如果不是家長課程的一部分，請留空）
-DocType: Leave Control Panel,Leave blank if considered for all employee types,保持空白如果考慮到所有的員工類型
-DocType: Landed Cost Voucher,Distribute Charges Based On,分銷費基於
-DocType: Projects Settings,Timesheets,時間表
-DocType: HR Settings,HR Settings,人力資源設置
-DocType: Salary Slip,net pay info,淨工資信息
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +334,CESS Amount,CESS金額
-DocType: Woocommerce Settings,Enable Sync,啟用同步
-DocType: Tax Withholding Rate,Single Transaction Threshold,單一交易閾值
-DocType: Lab Test Template,This value is updated in the Default Sales Price List.,該值在默認銷售價格表中更新。
-DocType: Email Digest,New Expenses,新的費用
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +123,PDC/LC Amount,PDC / LC金額
-DocType: Shareholder,Shareholder,股東
-DocType: Purchase Invoice,Additional Discount Amount,額外的折扣金額
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1803,Get Items from Prescriptions,從Prescriptions獲取物品
-DocType: Patient,Patient Details,患者細節
-DocType: Inpatient Record,B Positive,B積極
-apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +31,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of previous claimed\
+This is based on stock movement. See {0} for details,這是基於庫存移動。見{0}詳情
+Selling,銷售
+Amount {0} {1} deducted against {2},金額{0} {1}抵扣{2}
+Name and Employee ID,姓名和僱員ID,
+Website Item Group,網站項目群組
+No salary slip found to submit for the above selected criteria OR salary slip already submitted,沒有發現提交上述選定標准或已提交工資單的工資單
+Duties and Taxes,關稅和稅款
+Projects Settings,項目設置
+Please enter Reference date,參考日期請輸入
+{0} payment entries can not be filtered by {1},{0}付款分錄不能由{1}過濾
+Table for Item that will be shown in Web Site,表項，將在網站顯示出來
+Supplied Qty,附送數量
+Material Request Item,物料需求項目
+Please cancel Purchase Receipt {0} first,請先取消購買收據{0}
+Tree of Item Groups.,項目群組樹。
+Total Produced Qty,總生產數量
+Cannot refer row number greater than or equal to current row number for this Charge type,不能引用的行號大於或等於當前行號碼提供給充電式
+Item-wise Purchase History,全部項目的購買歷史
+Please click on 'Generate Schedule' to fetch Serial No added for Item {0},請點擊“生成表”來獲取序列號增加了對項目{0}
+Frozen,凍結的
+Vehicle Type,車輛類型
+Base Amount (Company Currency),基本金額（公司幣種）
+Raw Materials,原料
+Installation Time,安裝時間
+Accounting Details,會計細節
+status html,狀態HTML,
+Delete all the Transactions for this Company,刪除所有交易本公司
+O Positive,O積極
+Investments,投資
+Resolution Details,詳細解析
+Transaction Type,交易類型
+Acceptance Criteria,驗收標準
+Please enter Material Requests in the above table,請輸入在上表請求材料
+No repayments available for Journal Entry,沒有可用於日記帳分錄的還款
+Image List,圖像列表
+Attribute Name,屬性名稱
+Generate Invoice At Beginning Of Period,在期初生成發票
+Show In Website,顯示在網站
+Total Payable Amount,合計應付額
+Expected Time (in hours),預期時間（以小時計）
+Check in (group),檢查（組）
+Qty to Order,訂購數量
+"The account head under Liability or Equity, in which Profit/Loss will be booked",負債或權益下的科目頭，其中利潤/虧損將被黃牌警告
+Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},對於財務年度{4}，{1}&#39;{2}&#39;和科目“{3}”已存在另一個預算記錄“{0}”
+Gantt chart of all tasks.,所有任務的甘特圖。
+Mins to First Response,分鐘為第一個反應
+Margin Type,保證金類型
+{0} hours,{0}小時
+Default Grading Scale,默認等級規模
+For Employee Name,對於員工姓名
+Tax Account,稅收科目
+Invoice No,發票號碼
+Room Name,房間名稱
+Prescription Duration,處方時間
+"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}",離開不能應用/前{0}取消，因為假平衡已經被搬入轉發在未來休假分配記錄{1}
+Customer Addresses And Contacts,客戶的地址和聯絡方式
+Campaign Efficiency,運動效率
+Campaign Efficiency,運動效率
+Discussion,討論
+Transaction ID,事務ID,
+Deduct Tax For Unsubmitted Tax Exemption Proof,扣除未提交免稅證明的稅額
+Anytime,任何時候
+Bank Account No,銀行帳號
+Employee Tax Exemption Proof Submission,員工免稅證明提交
+Surgical History,手術史
+Mapped Header,映射的標題
+Resignation Letter Date,辭退信日期
+Pricing Rules are further filtered based on quantity.,定價規則進一步過濾基於數量。
+Please set the Date Of Joining for employee {0},請為員工{0}設置加入日期
+Please set the Date Of Joining for employee {0},請為員工{0}設置加入日期
+Discharge,卸貨
+Total Billing Amount (via Time Sheet),總開票金額（通過時間表）
+Repeat Customer Revenue,重複客戶收入
+Mapped Items,映射項目
+IT,它
+Chapter,章節
+Pair,對
+Default account will be automatically updated in POS Invoice when this mode is selected.,選擇此模式後，默認帳戶將在POS發票中自動更新。
+Select BOM and Qty for Production,選擇BOM和數量生產
+Depreciation Schedule,折舊計劃
+Sales Partner Addresses And Contacts,銷售合作夥伴地址和聯繫人
+Against Account,針對帳戶
+Half Day Date should be between From Date and To Date,半天時間應該是從之間的日期和終止日期
+Actual Date,實際日期
+Please set the Default Cost Center in {0} company.,請在{0}公司中設置默認成本中心。
+Has Batch No,有批號
+Shopify Webhook Detail,Shopify Webhook詳細信息
+Goods and Services Tax (GST India),商品和服務稅（印度消費稅）
+Excise Page Number,消費頁碼
+Purchase Date,購買日期
+Could not generate Secret,無法生成秘密
+Volunteer Type,志願者類型
+Shift Type,班次類型
+Personal Details,個人資料
+Please set 'Asset Depreciation Cost Center' in Company {0},請設置在公司的資產折舊成本中心“{0}
+Maintenance Schedules,保養時間表
+Actual End Date (via Time Sheet),實際結束日期（通過時間表）
+Soil Type,土壤類型
+Amount {0} {1} against {2} {3},量{0} {1}對{2} {3}
+Quotation Trends,報價趨勢
+Item Group not mentioned in item master for item {0},項目{0}之項目主檔未提及之項目群組
+GoCardless Mandate,GoCardless任務
+Debit To account must be a Receivable account,借方科目必須是應收帳款科目
+Shipping Amount,航運量
+Period Score,期間得分
+Add Customers,添加客戶
+Pending Amount,待審核金額
+Special,特別
+Conversion Factor,轉換因子
+Delivered,交付
+Vehicle Expenses,車輛費用
+Create Lab Test(s) on Sales Invoice Submit,在銷售發票上創建實驗室測試提交
+Invoice Details,發票明細
+Please enable Google Maps Settings to estimate and optimize routes,請啟用Google地圖設置以估算和優化路線
+Show on Website,在網站上顯示
+Start on,開始
+Hub Category,中心類別
+Vehicle Number,車號
+Loan Amount,貸款額度
+Add Letterhead,添加信頭
+Self-Driving Vehicle,自駕車
+Supplier Scorecard Standing,供應商記分卡站立
+Row {0}: Bill of Materials not found for the Item {1},行{0}：材料清單未找到項目{1}
+Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,共分配葉{0}不能小於已經批准葉{1}期間
+Accounts Receivable,應收帳款
+Supplier-Wise Sales Analytics,供應商相關的銷售分析
+Availed ITC Central Tax,有效的ITC中央稅收
+Company Address Name,公司地址名稱
+Use Multi-Level BOM,採用多級物料清單
+Include Reconciled Entries,包括對賬項目
+"Parent Course (Leave blank, if this isn't part of Parent Course)",家長課程（如果不是家長課程的一部分，請留空）
+"Parent Course (Leave blank, if this isn't part of Parent Course)",家長課程（如果不是家長課程的一部分，請留空）
+Leave blank if considered for all employee types,保持空白如果考慮到所有的員工類型
+Distribute Charges Based On,分銷費基於
+Timesheets,時間表
+HR Settings,人力資源設置
+net pay info,淨工資信息
+CESS Amount,CESS金額
+Enable Sync,啟用同步
+Single Transaction Threshold,單一交易閾值
+This value is updated in the Default Sales Price List.,該值在默認銷售價格表中更新。
+New Expenses,新的費用
+PDC/LC Amount,PDC / LC金額
+Shareholder,股東
+Additional Discount Amount,額外的折扣金額
+Get Items from Prescriptions,從Prescriptions獲取物品
+Patient Details,患者細節
+B Positive,B積極
+"Maximum benefit of employee {0} exceeds {1} by the sum {2} of previous claimed\
 			amount",員工{0}的最大權益超過{1}，前面聲明的金額\金額為{2}
-apps/erpnext/erpnext/controllers/accounts_controller.py +671,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.",行＃{0}：訂購數量必須是1，因為項目是固定資產。請使用單獨的行多數量。
-DocType: Leave Block List Allow,Leave Block List Allow,休假區塊清單准許
-apps/erpnext/erpnext/setup/doctype/company/company.py +349,Abbr can not be blank or space,縮寫不能為空白或輸入空白鍵
-DocType: Patient Medical Record,Patient Medical Record,病人醫療記錄
-apps/erpnext/erpnext/accounts/doctype/account/account.js +67,Group to Non-Group,集團以非組
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50,Sports,體育
-DocType: Loan Type,Loan Name,貸款名稱
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +85,Total Actual,實際總計
-DocType: Student Siblings,Student Siblings,學生兄弟姐妹
-DocType: Subscription Plan Detail,Subscription Plan Detail,訂閱計劃詳情
-apps/erpnext/erpnext/utilities/user_progress.py +146,Unit,單位
-apps/erpnext/erpnext/stock/get_item_details.py +157,Please specify Company,請註明公司
-,Customer Acquisition and Loyalty,客戶取得和忠誠度
-DocType: Asset Maintenance Task,Maintenance Task,維護任務
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +125,Please set B2C Limit in GST Settings.,請在GST設置中設置B2C限制。
-DocType: Marketplace Settings,Marketplace Settings,市場設置
-DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,你維護退貨庫存的倉庫
-DocType: Work Order,Skip Material Transfer,跳過材料轉移
-DocType: Work Order,Skip Material Transfer,跳過材料轉移
-apps/erpnext/erpnext/setup/utils.py +112,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,無法為關鍵日期{2}查找{0}到{1}的匯率。請手動創建貨幣兌換記錄
-DocType: POS Profile,Price List,價格表
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +22,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0}是現在預設的會計年度。請重新載入您的瀏覽器，以使更改生效。
-apps/erpnext/erpnext/projects/doctype/task/task.js +45,Expense Claims,報銷
-DocType: Employee Tax Exemption Declaration,Total Exemption Amount,免稅總額
-,BOM Search,BOM搜索
-DocType: Project,Total Consumed Material Cost  (via Stock Entry),總消耗材料成本（通過庫存輸入）
-DocType: Subscription,Subscription Period,訂閱期
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +169,To Date cannot be less than From Date,迄今不能少於起始日期
-DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",基於倉庫中的庫存，在Hub上發布“庫存”或“庫存”。
-DocType: Vehicle,Fuel Type,燃料類型
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27,Please specify currency in Company,請公司指定的貨幣
-DocType: Workstation,Wages per hour,時薪
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},在批量庫存餘額{0}將成為負{1}的在倉庫項目{2} {3}
-apps/erpnext/erpnext/templates/emails/reorder_item.html +1,Following Material Requests have been raised automatically based on Item's re-order level,下列資料的要求已自動根據項目的重新排序水平的提高
-apps/erpnext/erpnext/controllers/accounts_controller.py +376,Account {0} is invalid. Account Currency must be {1},科目{0}是無效的。科目貨幣必須是{1}
-apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py +31,From Date {0} cannot be after employee's relieving Date {1},起始日期{0}不能在員工解除日期之後{1}
-DocType: Supplier,Is Internal Supplier,是內部供應商
-DocType: Employee,Create User Permission,創建用戶權限
-DocType: Employee Benefit Claim,Employee Benefit Claim,員工福利索賠
-DocType: Healthcare Settings,Remind Before,提醒之前
-apps/erpnext/erpnext/buying/utils.py +34,UOM Conversion factor is required in row {0},計量單位換算係數是必需的行{0}
-DocType: Production Plan Item,material_request_item,material_request_item
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1120,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry",行＃{0}：參考文件類型必須是銷售訂單之一，銷售發票或日記帳分錄
-DocType: Loyalty Program,1 Loyalty Points = How much base currency?,1忠誠度積分=多少基礎貨幣？
-DocType: Item,Retain Sample,保留樣品
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,Row {0}: From Time and To Time is mandatory.,行{0}：從時間和時間是強制性的。
-DocType: Stock Reconciliation Item,Amount Difference,金額差異
-apps/erpnext/erpnext/stock/get_item_details.py +416,Item Price added for {0} in Price List {1},加入項目價格為{0}價格表{1}
-DocType: Delivery Stop,Order Information,訂單信息
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,請輸入這個銷售人員的員工標識
-DocType: Territory,Classification of Customers by region,客戶按區域分類
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +78,In Production,在生產中
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +66,Difference Amount must be zero,差量必須是零
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +74,{0} applicable after {1} working days,在{1}個工作日後適用{0}
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +60,Please enter Production Item first,請先輸入生產項目
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Calculated Bank Statement balance,計算的銀行對賬單餘額
-DocType: Normal Test Template,Normal Test Template,正常測試模板
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,禁用的用戶
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +970,Quotation,報價
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1041,Cannot set a received RFQ to No Quote,無法將收到的詢價單設置為無報價
-DocType: Salary Slip,Total Deduction,扣除總額
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +22,Select an account to print in account currency,選擇一個科目以科目貨幣進行打印
-,Production Analytics,生產Analytics（分析）
-apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6,This is based on transactions against this Patient. See timeline below for details,這是基於對這個病人的交易。有關詳情，請參閱下面的時間表
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +136,Item {0} has already been returned,項{0}已被退回
-DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,**財年**表示財政年度。所有的會計輸入項目和其他重大交易針對**財年**進行追蹤。
-DocType: Opportunity,Customer / Lead Address,客戶/鉛地址
-DocType: Supplier Scorecard Period,Supplier Scorecard Setup,供應商記分卡設置
-apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,評估計劃名稱
-DocType: Work Order Operation,Work Order Operation,工作訂單操作
-apps/erpnext/erpnext/stock/doctype/item/item.py +262,Warning: Invalid SSL certificate on attachment {0},警告：附件無效的SSL證書{0}
-apps/erpnext/erpnext/utilities/activation.py +64,"Leads help you get business, add all your contacts and more as your leads",信息幫助你的業務，你所有的聯繫人和更添加為您的線索
-DocType: Work Order Operation,Actual Operation Time,實際操作時間
-DocType: Authorization Rule,Applicable To (User),適用於（用戶）
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196,Job Description,職位描述
-DocType: Student Applicant,Applied,應用的
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +942,Re-open,重新打開
-DocType: Sales Invoice Item,Qty as per Stock UOM,數量按庫存計量單位
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Guardian2名稱
-DocType: Attendance,Attendance Request,出席請求
-DocType: Purchase Invoice,02-Post Sale Discount,02-售後折扣
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +139,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series",特殊字符除了“ - ”，“”，“＃”，和“/”未命名序列允許
-DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.",追蹤銷售計劃。追踪訊息，報價，銷售訂單等，從競賽來衡量投資報酬。
-apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py +115,You can't redeem Loyalty Points having more value than the Grand Total.,您無法兌換價值超過總計的忠誠度積分。
-DocType: Department Approver,Approver,審批人
-,SO Qty,SO數量
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +92,The field To Shareholder cannot be blank,“股東”字段不能為空
-DocType: Appraisal,Calculate Total Score,計算總分
-DocType: Employee,Health Insurance,健康保險
-DocType: Asset Repair,Manufacturing Manager,生產經理
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191,Serial No {0} is under warranty upto {1},序列號{0}在保修期內直到{1}
-DocType: Plant Analysis Criteria,Minimum Permissible Value,最小允許值
-apps/erpnext/erpnext/education/doctype/guardian/guardian.py +41,User {0} already exists,用戶{0}已經存在
-apps/erpnext/erpnext/hooks.py +115,Shipments,發貨
-DocType: Payment Entry,Total Allocated Amount (Company Currency),總撥款額（公司幣種）
-DocType: Purchase Order Item,To be delivered to customer,要傳送給客戶
-DocType: BOM,Scrap Material Cost,廢料成本
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +243,Serial No {0} does not belong to any Warehouse,序列號{0}不屬於任何倉庫
-DocType: Grant Application,Email Notification Sent,電子郵件通知已發送
-DocType: Purchase Invoice,In Words (Company Currency),大寫（Company Currency）
-apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py +24,Company is manadatory for company account,公司是公司科目的管理者
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1092,"Item Code, warehouse, quantity are required on row",在行上需要項目代碼，倉庫，數量
-DocType: Bank Guarantee,Supplier,供應商
-apps/erpnext/erpnext/hr/doctype/department/department.js +9,This is a root department and cannot be edited.,這是根部門，無法編輯。
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41,Show Payment Details,顯示付款詳情
-apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py +53,Duration in Days,持續時間天數
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +113,Miscellaneous Expenses,雜項開支
-DocType: Global Defaults,Default Company,預設公司
-DocType: Company,Transactions Annual History,交易年曆
-apps/erpnext/erpnext/controllers/stock_controller.py +231,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,對項目{0}而言， 費用或差異科目是強制必填的，因為它影響整個庫存總值。
-DocType: Bank,Bank Name,銀行名稱
-apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +78,-Above,-以上
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1301,Leave the field empty to make purchase orders for all suppliers,將該字段留空以為所有供應商下達採購訂單
-DocType: Healthcare Practitioner,Inpatient Visit Charge Item,住院訪問費用項目
-DocType: Vital Signs,Fluid,流體
-DocType: Leave Application,Total Leave Days,總休假天數
-DocType: Email Digest,Note: Email will not be sent to disabled users,注意：電子郵件將不會被發送到被禁用的用戶
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,交互次數
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,交互次數
-apps/erpnext/erpnext/stock/doctype/item/item.js +107,Item Variant Settings,項目變式設置
-apps/erpnext/erpnext/public/js/account_tree_grid.js +57,Select Company...,選擇公司...
-DocType: Leave Control Panel,Leave blank if considered for all departments,保持空白如果考慮到全部部門
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +506,{0} is mandatory for Item {1},{0}是強制性的項目{1}
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +149,"Item {0}: {1} qty produced, ",項目{0}：{1}產生的數量，
-DocType: Currency Exchange,From Currency,從貨幣
-DocType: Vital Signs,Weight (In Kilogram),體重（公斤）
-DocType: Chapter,"chapters/chapter_name
+"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.",行＃{0}：訂購數量必須是1，因為項目是固定資產。請使用單獨的行多數量。
+Leave Block List Allow,休假區塊清單准許
+Abbr can not be blank or space,縮寫不能為空白或輸入空白鍵
+Patient Medical Record,病人醫療記錄
+Group to Non-Group,集團以非組
+Sports,體育
+Loan Name,貸款名稱
+Total Actual,實際總計
+Student Siblings,學生兄弟姐妹
+Subscription Plan Detail,訂閱計劃詳情
+Unit,單位
+Please specify Company,請註明公司
+Customer Acquisition and Loyalty,客戶取得和忠誠度
+Maintenance Task,維護任務
+Please set B2C Limit in GST Settings.,請在GST設置中設置B2C限制。
+Marketplace Settings,市場設置
+Warehouse where you are maintaining stock of rejected items,你維護退貨庫存的倉庫
+Skip Material Transfer,跳過材料轉移
+Skip Material Transfer,跳過材料轉移
+Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,無法為關鍵日期{2}查找{0}到{1}的匯率。請手動創建貨幣兌換記錄
+Price List,價格表
+{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0}是現在預設的會計年度。請重新載入您的瀏覽器，以使更改生效。
+Expense Claims,報銷
+Total Exemption Amount,免稅總額
+BOM Search,BOM搜索
+Total Consumed Material Cost  (via Stock Entry),總消耗材料成本（通過庫存輸入）
+Subscription Period,訂閱期
+To Date cannot be less than From Date,迄今不能少於起始日期
+"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",基於倉庫中的庫存，在Hub上發布“庫存”或“庫存”。
+Fuel Type,燃料類型
+Please specify currency in Company,請公司指定的貨幣
+Wages per hour,時薪
+Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},在批量庫存餘額{0}將成為負{1}的在倉庫項目{2} {3}
+Following Material Requests have been raised automatically based on Item's re-order level,下列資料的要求已自動根據項目的重新排序水平的提高
+Account {0} is invalid. Account Currency must be {1},科目{0}是無效的。科目貨幣必須是{1}
+From Date {0} cannot be after employee's relieving Date {1},起始日期{0}不能在員工解除日期之後{1}
+Is Internal Supplier,是內部供應商
+Create User Permission,創建用戶權限
+Employee Benefit Claim,員工福利索賠
+Remind Before,提醒之前
+UOM Conversion factor is required in row {0},計量單位換算係數是必需的行{0}
+material_request_item,material_request_item,
+"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry",行＃{0}：參考文件類型必須是銷售訂單之一，銷售發票或日記帳分錄
+1 Loyalty Points = How much base currency?,1忠誠度積分=多少基礎貨幣？
+Retain Sample,保留樣品
+Row {0}: From Time and To Time is mandatory.,行{0}：從時間和時間是強制性的。
+Amount Difference,金額差異
+Item Price added for {0} in Price List {1},加入項目價格為{0}價格表{1}
+Order Information,訂單信息
+Please enter Employee Id of this sales person,請輸入這個銷售人員的員工標識
+Classification of Customers by region,客戶按區域分類
+In Production,在生產中
+Difference Amount must be zero,差量必須是零
+{0} applicable after {1} working days,在{1}個工作日後適用{0}
+Please enter Production Item first,請先輸入生產項目
+Calculated Bank Statement balance,計算的銀行對賬單餘額
+Normal Test Template,正常測試模板
+disabled user,禁用的用戶
+Quotation,報價
+Cannot set a received RFQ to No Quote,無法將收到的詢價單設置為無報價
+Total Deduction,扣除總額
+Select an account to print in account currency,選擇一個科目以科目貨幣進行打印
+Production Analytics,生產Analytics（分析）
+This is based on transactions against this Patient. See timeline below for details,這是基於對這個病人的交易。有關詳情，請參閱下面的時間表
+Item {0} has already been returned,項{0}已被退回
+**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,**財年**表示財政年度。所有的會計輸入項目和其他重大交易針對**財年**進行追蹤。
+Customer / Lead Address,客戶/鉛地址
+Supplier Scorecard Setup,供應商記分卡設置
+Assessment Plan Name,評估計劃名稱
+Work Order Operation,工作訂單操作
+Warning: Invalid SSL certificate on attachment {0},警告：附件無效的SSL證書{0}
+"Leads help you get business, add all your contacts and more as your leads",信息幫助你的業務，你所有的聯繫人和更添加為您的線索
+Actual Operation Time,實際操作時間
+Applicable To (User),適用於（用戶）
+Job Description,職位描述
+Applied,應用的
+Re-open,重新打開
+Qty as per Stock UOM,數量按庫存計量單位
+Guardian2 Name,Guardian2名稱
+Attendance Request,出席請求
+02-Post Sale Discount,02-售後折扣
+"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series",特殊字符除了“ - ”，“”，“＃”，和“/”未命名序列允許
+"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.",追蹤銷售計劃。追踪訊息，報價，銷售訂單等，從競賽來衡量投資報酬。
+You can't redeem Loyalty Points having more value than the Grand Total.,您無法兌換價值超過總計的忠誠度積分。
+Approver,審批人
+SO Qty,SO數量
+The field To Shareholder cannot be blank,“股東”字段不能為空
+Calculate Total Score,計算總分
+Health Insurance,健康保險
+Manufacturing Manager,生產經理
+Serial No {0} is under warranty upto {1},序列號{0}在保修期內直到{1}
+Minimum Permissible Value,最小允許值
+User {0} already exists,用戶{0}已經存在
+Shipments,發貨
+Total Allocated Amount (Company Currency),總撥款額（公司幣種）
+To be delivered to customer,要傳送給客戶
+Scrap Material Cost,廢料成本
+Serial No {0} does not belong to any Warehouse,序列號{0}不屬於任何倉庫
+Email Notification Sent,電子郵件通知已發送
+In Words (Company Currency),大寫（Company Currency）
+Company is manadatory for company account,公司是公司科目的管理者
+"Item Code, warehouse, quantity are required on row",在行上需要項目代碼，倉庫，數量
+Supplier,供應商
+This is a root department and cannot be edited.,這是根部門，無法編輯。
+Show Payment Details,顯示付款詳情
+Duration in Days,持續時間天數
+Miscellaneous Expenses,雜項開支
+Default Company,預設公司
+Transactions Annual History,交易年曆
+Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,對項目{0}而言， 費用或差異科目是強制必填的，因為它影響整個庫存總值。
+Bank Name,銀行名稱
+-Above,-以上
+Leave the field empty to make purchase orders for all suppliers,將該字段留空以為所有供應商下達採購訂單
+Inpatient Visit Charge Item,住院訪問費用項目
+Fluid,流體
+Total Leave Days,總休假天數
+Note: Email will not be sent to disabled users,注意：電子郵件將不會被發送到被禁用的用戶
+Number of Interaction,交互次數
+Number of Interaction,交互次數
+Item Variant Settings,項目變式設置
+Select Company...,選擇公司...
+Leave blank if considered for all departments,保持空白如果考慮到全部部門
+{0} is mandatory for Item {1},{0}是強制性的項目{1}
+"Item {0}: {1} qty produced, ",項目{0}：{1}產生的數量，
+From Currency,從貨幣
+Weight (In Kilogram),體重（公斤）
+"chapters/chapter_name,
 leave blank automatically set after saving chapter.",保存章節後自動設置章節/章節名稱。
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +218,Please set GST Accounts in GST Settings,請在GST設置中設置GST帳戶
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +46,Type of Business,業務類型
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +171,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row",請ATLEAST一行選擇分配金額，發票類型和發票號碼
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +143,Cost of New Purchase,新的採購成本
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +98,Sales Order required for Item {0},所需的{0}項目銷售訂單
-DocType: Grant Application,Grant Description,授予說明
-DocType: Purchase Invoice Item,Rate (Company Currency),率（公司貨幣）
-DocType: Payment Entry,Unallocated Amount,未分配金額
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +77,Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,請啟用適用於採購訂單並適用於預訂實際費用
-apps/erpnext/erpnext/templates/includes/product_page.js +101,Cannot find a matching Item. Please select some other value for {0}.,無法找到匹配的項目。請選擇其他值{0}。
-DocType: POS Profile,Taxes and Charges,稅收和收費
-DocType: Item,"A Product or a Service that is bought, sold or kept in stock.",產品或服務已購買，出售或持有的庫存。
-apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44,No more updates,沒有更多的更新
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +184,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,不能選擇充電式為'在上一行量'或'在上一行總'的第一行
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6,This covers all scorecards tied to this Setup,這涵蓋了與此安裝程序相關的所有記分卡
-apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29,Child Item should not be a Product Bundle. Please remove item `{0}` and save,子項不應該是一個產品包。請刪除項目`{0}`和保存
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12,Banking,銀行業
-apps/erpnext/erpnext/utilities/activation.py +108,Add Timesheets,添加時間表
-DocType: Vehicle Service,Service Item,服務項目
-DocType: Bank Guarantee,Bank Guarantee,銀行擔保
-DocType: Bank Guarantee,Bank Guarantee,銀行擔保
-DocType: Payment Request,Transaction Details,交易明細
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,請在“產生排程”點擊以得到排程表
-DocType: Blanket Order Item,Ordered Quantity,訂購數量
-apps/erpnext/erpnext/public/js/setup_wizard.js +118,"e.g. ""Build tools for builders""",例如「建設建設者工具“
-DocType: Grading Scale,Grading Scale Intervals,分級刻度間隔
-DocType: Item Default,Purchase Defaults,購買默認值
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +117,Make Job Card,製作工作卡
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +329,"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again",無法自動創建Credit Note，請取消選中&#39;Issue Credit Note&#39;並再次提交
-apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Profit for the year,年度利潤
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +126,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}在{2}會計分錄只能在貨幣言：{3}
-DocType: Fee Schedule,In Process,在過程
-DocType: Authorization Rule,Itemwise Discount,Itemwise折扣
-apps/erpnext/erpnext/config/accounts.py +53,Tree of financial accounts.,財務賬目的樹。
-DocType: Bank Guarantee,Reference Document Type,參考文檔類型
-DocType: Cash Flow Mapping,Cash Flow Mapping,現金流量映射
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +400,{0} against Sales Order {1},{0}針對銷售訂單{1}
-DocType: Account,Fixed Asset,固定資產
-DocType: Amazon MWS Settings,After Date,日期之後
-apps/erpnext/erpnext/config/stock.py +327,Serialized Inventory,序列化庫存
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1173,Invalid {0} for Inter Company Invoice.,Inter公司發票無效的{0}。
-,Department Analytics,部門分析
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74,Email not found in default contact,在默認聯繫人中找不到電子郵件
-DocType: Loan,Account Info,帳戶信息
-DocType: Activity Type,Default Billing Rate,默認計費率
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0}創建學生組。
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0}創建學生組。
-DocType: Sales Invoice,Total Billing Amount,總結算金額
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50,Program in the Fee Structure and Student Group {0} are different.,費用結構和學生組{0}中的課程是不同的。
-DocType: Bank Statement Transaction Entry,Receivable Account,應收帳款
-apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +31,Valid From Date must be lesser than Valid Upto Date.,有效起始日期必須小於有效起始日期。
-apps/erpnext/erpnext/controllers/accounts_controller.py +689,Row #{0}: Asset {1} is already {2},行＃{0}：資產{1}已經是{2}
-DocType: Quotation Item,Stock Balance,庫存餘額
-apps/erpnext/erpnext/config/selling.py +327,Sales Order to Payment,銷售訂單到付款
-DocType: Purchase Invoice,With Payment of Tax,繳納稅款
-DocType: Expense Claim Detail,Expense Claim Detail,報銷詳情
-DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,供應商提供服務
-DocType: Exchange Rate Revaluation Account,New Balance In Base Currency,基礎貨幣的新平衡
-DocType: Crop Cycle,This will be day 1 of the crop cycle,這將是作物週期的第一天
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +915,Please select correct account,請選擇正確的科目
-DocType: Salary Structure Assignment,Salary Structure Assignment,薪酬結構分配
-DocType: Purchase Invoice Item,Weight UOM,重量計量單位
-apps/erpnext/erpnext/config/accounts.py +435,List of available Shareholders with folio numbers,包含folio號碼的可用股東名單
-DocType: Salary Structure Employee,Salary Structure Employee,薪資結構員工
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +62,Show Variant Attributes,顯示變體屬性
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +48,The payment gateway account in plan {0} is different from the payment gateway account in this payment request,計劃{0}中的支付閘道科目與此付款請求中的支付閘道科目不同
-DocType: Course,Course Name,課程名
-apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py +50,No Tax Withholding data found for the current Fiscal Year.,未找到當前財年的預扣稅數據。
-DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,用戶可以批准特定員工的休假申請
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +53,Office Equipments,辦公設備
-DocType: Purchase Invoice Item,Qty,數量
-DocType: Fiscal Year,Companies,企業
-DocType: Supplier Scorecard,Scoring Setup,得分設置
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,電子
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +364,Debit ({0}),借記卡（{0}）
-DocType: BOM,Allow Same Item Multiple Times,多次允許相同的項目
-DocType: Stock Settings,Raise Material Request when stock reaches re-order level,當庫存到達需重新訂購水平時提高物料需求
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +76,Full-time,全日制
-DocType: Payroll Entry,Employees,僱員
-DocType: Employee,Contact Details,聯絡方式
-DocType: C-Form,Received Date,接收日期
-DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.",如果您已經創建了銷售稅和費模板標準模板，選擇一個，然後點擊下面的按鈕。
-DocType: BOM Scrap Item,Basic Amount (Company Currency),基本金額（公司幣種）
-DocType: Student,Guardians,守護者
-apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html +13,Payment Confirmation,付款確認
-DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,價格將不會顯示如果沒有設置價格
-DocType: Stock Entry,Total Incoming Value,總收入值
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434,Debit To is required,借方是必填項
-DocType: Clinical Procedure,Inpatient Record,住院病歷
-apps/erpnext/erpnext/utilities/activation.py +109,"Timesheets help keep track of time, cost and billing for activites done by your team",時間表幫助追踪的時間，費用和結算由你的團隊做activites
-apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +41,Purchase Price List,採購價格表
-apps/erpnext/erpnext/config/buying.py +155,Templates of supplier scorecard variables.,供應商記分卡變數模板。
-DocType: Job Offer Term,Offer Term,要約期限
-DocType: Asset,Quality Manager,質量經理
-DocType: Job Applicant,Job Opening,開放職位
-DocType: Payment Reconciliation,Payment Reconciliation,付款對帳
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153,Please select Incharge Person's name,請選擇Incharge人的名字
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51,Technology,技術
-DocType: BOM Website Operation,BOM Website Operation,BOM網站運營
-DocType: Bank Statement Transaction Payment Item,outstanding_amount,outstanding_amount
-DocType: Supplier Scorecard,Supplier Score,供應商分數
-apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js +37,Schedule Admission,安排入場
-DocType: Tax Withholding Rate,Cumulative Transaction Threshold,累積交易閾值
-apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +27,Total Invoiced Amt,總開票金額
-DocType: BOM,Conversion Rate,兌換率
-apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,產品搜索
-DocType: Cashier Closing,To Time,要時間
-apps/erpnext/erpnext/hr/utils.py +202,) for {0},）為{0}
-DocType: Authorization Rule,Approving Role (above authorized value),批准角色（上述授權值）
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +147,Credit To account must be a Payable account,信用科目必須是應付帳款
-DocType: Loan,Total Amount Paid,總金額支付
-DocType: Asset,Insurance End Date,保險終止日期
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,請選擇付費學生申請者必須入學的學生
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +370,BOM recursion: {0} cannot be parent or child of {2},BOM遞歸： {0}不能父母或兒童{2}
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +40,Budget List,預算清單
-DocType: Work Order Operation,Completed Qty,完成數量
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +180,"For {0}, only debit accounts can be linked against another credit entry",{0}，只有借方科目可以連接另一個貸方分錄
-DocType: Manufacturing Settings,Allow Overtime,允許加班
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +149,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry",序列化項目{0}無法使用庫存調節更新，請使用庫存條目
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +149,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry",序列化項目{0}無法使用庫存調節更新，請使用庫存條目
-DocType: Training Event Employee,Training Event Employee,培訓活動的員工
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1299,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,可以為批次{1}和項目{2}保留最大樣本數量{0}。
-apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +7,Add Time Slots,添加時間插槽
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +206,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0}產品{1}需要的序號。您已提供{2}。
-DocType: Stock Reconciliation Item,Current Valuation Rate,目前的估值價格
-DocType: Training Event,Advance,提前
-apps/erpnext/erpnext/config/integrations.py +13,GoCardless payment gateway settings,GoCardless支付網關設置
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +129,Exchange Gain/Loss,兌換收益/損失
-DocType: Opportunity,Lost Reason,失落的原因
-DocType: Amazon MWS Settings,Enable Amazon,啟用亞馬遜
-apps/erpnext/erpnext/controllers/accounts_controller.py +322,Row #{0}: Account {1} does not belong to company {2},行＃{0}：科目{1}不屬於公司{2}
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +30,Unable to find DocType {0},無法找到DocType {0}
-DocType: Quality Inspection,Sample Size,樣本大小
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47,Please enter Receipt Document,請輸入收據憑證
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +412,All items have already been invoiced,所有項目已開具發票
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49,Please specify a valid 'From Case No.',請指定一個有效的“從案號”
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24,Further cost centers can be made under Groups but entries can be made against non-Groups,進一步的成本中心可以根據組進行，但項可以對非組進行
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +40,Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,在此期間，總分配的離職時間超過員工{1}的最大分配{0}離職類型的天數
-apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,用戶和權限
-DocType: Branch,Branch,分支機構
-DocType: Soil Analysis,Ca/(K+Ca+Mg),的Ca /（K +鈣+鎂）
-DocType: Delivery Trip,Fulfillment User,履行用戶
-DocType: Company,Total Monthly Sales,每月銷售總額
-DocType: Payment Request,Subscription Plans,訂閱計劃
-DocType: Agriculture Analysis Criteria,Weather,天氣
-DocType: Bin,Actual Quantity,實際數量
-DocType: Shipping Rule,example: Next Day Shipping,例如：次日發貨
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187,Serial No {0} not found,序列號{0}未找到
-DocType: Fee Schedule Program,Fee Schedule Program,費用計劃計劃
-DocType: Fee Schedule Program,Student Batch,學生批
-apps/erpnext/erpnext/utilities/activation.py +119,Make Student,使學生
-DocType: Supplier Scorecard Scoring Standing,Min Grade,最小成績
-DocType: Healthcare Service Unit Type,Healthcare Service Unit Type,醫療服務單位類型
-apps/erpnext/erpnext/projects/doctype/project/project.py +279,You have been invited to collaborate on the project: {0},您已被邀請在項目上進行合作：{0}
-DocType: Supplier Group,Parent Supplier Group,父供應商組
-DocType: Email Digest,Purchase Orders to Bill,向比爾購買訂單
-apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js +54,Accumulated Values in Group Company,集團公司累計價值
-DocType: Leave Block List Date,Block Date,封鎖日期
-DocType: Purchase Receipt,Supplier Delivery Note,供應商交貨單
-apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70,Apply Now,現在申請
-DocType: Employee Tax Exemption Proof Submission Detail,Type of Proof,證明類型
-apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},實際數量{0} /等待數量{1}
-apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},實際數量{0} /等待數量{1}
-DocType: Purchase Invoice,E-commerce GSTIN,電子商務GSTIN
-,Bank Clearance Summary,銀行結算摘要
-apps/erpnext/erpnext/config/setup.py +100,"Create and manage daily, weekly and monthly email digests.",建立和管理每日，每週和每月的電子郵件摘要。
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_dashboard.py +6,This is based on transactions against this Sales Person. See timeline below for details,這是基於針對此銷售人員的交易。請參閱下面的時間表了解詳情
-DocType: Appraisal Goal,Appraisal Goal,考核目標
-DocType: Stock Reconciliation Item,Current Amount,電流量
-apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.py +24,Tax Declaration of {0} for period {1} already submitted.,已提交期間{1}的稅務申報{0}。
-apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +76,Leaves has been granted sucessfully,葉子已成功獲得
-DocType: Fee Schedule,Fee Structure,費用結構
-DocType: Timesheet Detail,Costing Amount,成本核算金額
-DocType: Student Admission Program,Application Fee,報名費
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +75,Submit Salary Slip,提交工資單
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +13,On Hold,等候接聽
-DocType: Account,Inter Company Account,公司內帳戶
-apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +17,Import in Bulk,進口散裝
-DocType: Sales Partner,Address & Contacts,地址及聯絡方式
-DocType: SMS Log,Sender Name,發件人名稱
-DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,農業分析標準
-DocType: HR Settings,Leave Approval Notification Template,留下批准通知模板
-DocType: POS Profile,[Select],[選擇]
-DocType: Staffing Plan Detail,Number Of Positions,職位數
-DocType: Vital Signs,Blood Pressure (diastolic),血壓（舒張）
-DocType: SMS Log,Sent To,發給
-DocType: Payment Request,Make Sales Invoice,做銷售發票
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +62,Softwares,軟件
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +53,Next Contact Date cannot be in the past,接下來跟日期不能過去
-DocType: Company,For Reference Only.,僅供參考。
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2595,Select Batch No,選擇批號
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +80,Invalid {0}: {1},無效的{0}：{1}
-DocType: Fee Validity,Reference Inv,參考文獻
-DocType: Sales Invoice Advance,Advance Amount,提前量
-DocType: Manufacturing Settings,Capacity Planning,產能規劃
-DocType: Supplier Quotation,Rounding Adjustment (Company Currency,四捨五入調整（公司貨幣）
-DocType: Asset,Policy number,保單號碼
-DocType: Journal Entry,Reference Number,參考號碼
-DocType: Employee,New Workplace,新工作空間
-DocType: Retention Bonus,Retention Bonus,保留獎金
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,設置為關閉
-apps/erpnext/erpnext/stock/get_item_details.py +146,No Item with Barcode {0},沒有條碼{0}的品項
-DocType: Normal Test Items,Require Result Value,需要結果值
-DocType: Item,Show a slideshow at the top of the page,顯示幻燈片在頁面頂部
-DocType: Tax Withholding Rate,Tax Withholding Rate,稅收預扣稅率
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +552,Boms,物料清單
-apps/erpnext/erpnext/stock/doctype/item/item.py +191,Stores,商店
-DocType: Project Type,Projects Manager,項目經理
-DocType: Serial No,Delivery Time,交貨時間
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +15,Ageing Based On,老齡化基於
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +103,Appointment cancelled,預約被取消
-DocType: Item,End of Life,壽命結束
-apps/erpnext/erpnext/demo/setup/setup_data.py +344,Travel,旅遊
-DocType: Student Report Generation Tool,Include All Assessment Group,包括所有評估小組
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +266,No active or default Salary Structure found for employee {0} for the given dates,發現員工{0}對於給定的日期沒有活動或默認的薪酬結構
-DocType: Leave Block List,Allow Users,允許用戶
-DocType: Purchase Order,Customer Mobile No,客戶手機號碼
-DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,現金流量映射模板細節
-apps/erpnext/erpnext/config/non_profit.py +68,Loan Management,貸款管理
-DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,跟踪獨立收入和支出進行產品垂直或部門。
-DocType: Item Reorder,Item Reorder,項目重新排序
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +488,Show Salary Slip,顯示工資單
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +881,Transfer Material,轉印材料
-DocType: Fees,Send Payment Request,發送付款請求
-DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.",指定作業、作業成本並給予該作業一個專屬的作業編號。
-DocType: Travel Request,Any other details,任何其他細節
-apps/erpnext/erpnext/controllers/status_updater.py +207,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,這份文件是超過限制，通過{0} {1}項{4}。你在做另一個{3}對同一{2}？
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1288,Please set recurring after saving,請設置保存後復發
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +874,Select change amount account,選擇變化量科目
-DocType: Purchase Invoice,Price List Currency,價格表之貨幣
-DocType: Naming Series,User must always select,用戶必須始終選擇
-DocType: Stock Settings,Allow Negative Stock,允許負庫存
-DocType: Installation Note,Installation Note,安裝注意事項
-DocType: Topic,Topic,話題
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +99,Cash Flow from Financing,從融資現金流
-DocType: Budget Account,Budget Account,預算科目
-DocType: Quality Inspection,Verified By,認證機構
-DocType: Travel Request,Name of Organizer,主辦單位名稱
-apps/erpnext/erpnext/setup/doctype/company/company.py +84,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.",不能改變公司的預設貨幣，因為有存在的交易。交易必須取消更改預設貨幣。
-DocType: Cash Flow Mapping,Is Income Tax Liability,是所得稅責任
-DocType: Grading Scale Interval,Grade Description,等級說明
-DocType: Clinical Procedure,Is Invoiced,已開票
-DocType: Stock Entry,Purchase Receipt No,採購入庫單編號
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +31,Earnest Money,保證金
-DocType: Sales Invoice, Shipping Bill Number,裝運單編號
-DocType: Asset Maintenance Log,Actions performed,已執行的操作
-DocType: Cash Flow Mapper,Section Leader,科長
-DocType: Delivery Note,Transport Receipt No,運輸收據編號
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +144,Source of Funds (Liabilities),資金來源（負債）
-apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +52,Source and Target Location cannot be same,源和目標位置不能相同
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +522,Quantity in row {0} ({1}) must be same as manufactured quantity {2},列{0}的數量（{1}）必須與生產量{2}相同
-DocType: Supplier Scorecard Scoring Standing,Employee,僱員
-DocType: Bank Guarantee,Fixed Deposit Number,定期存款編號
-DocType: Asset Repair,Failure Date,失敗日期
-DocType: Support Search Source,Result Title Field,結果標題字段
-DocType: Sample Collection,Collected Time,收集時間
-DocType: Company,Sales Monthly History,銷售月曆
-DocType: Asset Maintenance Task,Next Due Date,下一個到期日
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +242,Select Batch,選擇批次
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276,{0} {1} is fully billed,{0} {1}}已開票
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +30,Vital Signs,生命體徵
-DocType: Payment Entry,Payment Deductions or Loss,付款扣除或損失
-DocType: Soil Analysis,Soil Analysis Criterias,土壤分析標準
-apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,銷售或採購的標準合同條款。
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +56,Group by Voucher,集團透過券
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +391,Are you sure you want to cancel this appointment?,你確定要取消這個預約嗎？
-DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,酒店房間價格套餐
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +42,Sales Pipeline,銷售渠道
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +167,Please set default account in Salary Component {0},請薪酬部分設置默認科目{0}
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200,Please select BOM for Item in Row {0},請行選擇BOM為項目{0}
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +13,Fetch Subscription Updates,獲取訂閱更新
-apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account {0} does not match with Company {1} in Mode of Account: {2},帳戶{0}與帳戶模式{2}中的公司{1}不符
-apps/erpnext/erpnext/controllers/buying_controller.py +719,Specified BOM {0} does not exist for Item {1},指定BOM {0}的項目不存在{1}
-apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +301,Course: ,課程：
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +246,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,維護時間表{0}必須取消早於取消這個銷售訂單
-DocType: POS Profile,Applicable for Users,適用於用戶
-DocType: Notification Control,Expense Claim Approved,報銷批准
-DocType: Purchase Invoice,Set Advances and Allocate (FIFO),設置進度和分配（FIFO）
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231,No Work Orders created,沒有創建工作訂單
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +403,Salary Slip of employee {0} already created for this period,員工的工資單{0}已為這一時期創建
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +121,Pharmaceutical,製藥
-apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py +24,You can only submit Leave Encashment for a valid encashment amount,您只能提交離開封存以獲得有效的兌換金額
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,購買的物品成本
-DocType: Employee Separation,Employee Separation Template,員工分離模板
-DocType: Selling Settings,Sales Order Required,銷售訂單需求
-apps/erpnext/erpnext/public/js/hub/marketplace.js +106,Become a Seller,成為賣家
-DocType: Purchase Invoice,Credit To,信貸
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Active Leads / Customers,有效訊息/客戶
-DocType: Delivery Settings,Leave blank to use the standard Delivery Note format,留空以使用標準的交貨單格式
-DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,維護計劃細節
-DocType: Supplier Scorecard,Warn for new Purchase Orders,警告新的採購訂單
-DocType: Quality Inspection Reading,Reading 9,9閱讀
-DocType: Supplier,Is Frozen,就是冰凍
-apps/erpnext/erpnext/stock/utils.py +248,Group node warehouse is not allowed to select for transactions,組節點倉庫不允許選擇用於交易
-DocType: Buying Settings,Buying Settings,採購設定
-DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM編號為成品產品
-DocType: Upload Attendance,Attendance To Date,出席會議日期
-DocType: Request for Quotation Supplier,No Quote,沒有報價
-DocType: Support Search Source,Post Title Key,帖子標題密鑰
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +232,For Job Card,對於工作卡
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1556,Prescriptions,處方
-DocType: Payment Gateway Account,Payment Account,付款帳號
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +1112,Please specify Company to proceed,請註明公司以處理
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +81,Net Change in Accounts Receivable,應收帳款淨額變化
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66,Compensatory Off,補假
-DocType: Job Offer,Accepted,接受的
-DocType: POS Closing Voucher,Sales Invoices Summary,銷售發票摘要
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +225,To Party Name,到黨名
-DocType: Grant Application,Organization,組織
-DocType: Grant Application,Organization,組織
-DocType: BOM Update Tool,BOM Update Tool,BOM更新工具
-DocType: SG Creation Tool Course,Student Group Name,學生組名稱
-apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js +23,Show exploded view,顯示爆炸視圖
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,創造費用
-apps/erpnext/erpnext/setup/doctype/company/company.js +111,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,請確保你真的要刪除這家公司的所有交易。主數據將保持原樣。這個動作不能撤消。
-apps/erpnext/erpnext/templates/pages/product_search.html +21,Search Results,搜索結果
-DocType: Room,Room Number,房間號
-apps/erpnext/erpnext/utilities/transaction_base.py +112,Invalid reference {0} {1},無效的參考{0} {1}
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +187,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},"{0} ({1})不能大於計劃數量
+Please set GST Accounts in GST Settings,請在GST設置中設置GST帳戶
+Type of Business,業務類型
+"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row",請ATLEAST一行選擇分配金額，發票類型和發票號碼
+Cost of New Purchase,新的採購成本
+Sales Order required for Item {0},所需的{0}項目銷售訂單
+Grant Description,授予說明
+Rate (Company Currency),率（公司貨幣）
+Unallocated Amount,未分配金額
+Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,請啟用適用於採購訂單並適用於預訂實際費用
+Cannot find a matching Item. Please select some other value for {0}.,無法找到匹配的項目。請選擇其他值{0}。
+Taxes and Charges,稅收和收費
+"A Product or a Service that is bought, sold or kept in stock.",產品或服務已購買，出售或持有的庫存。
+No more updates,沒有更多的更新
+Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,不能選擇充電式為'在上一行量'或'在上一行總'的第一行
+This covers all scorecards tied to this Setup,這涵蓋了與此安裝程序相關的所有記分卡
+Child Item should not be a Product Bundle. Please remove item `{0}` and save,子項不應該是一個產品包。請刪除項目`{0}`和保存
+Banking,銀行業
+Add Timesheets,添加時間表
+Service Item,服務項目
+Bank Guarantee,銀行擔保
+Bank Guarantee,銀行擔保
+Transaction Details,交易明細
+Please click on 'Generate Schedule' to get schedule,請在“產生排程”點擊以得到排程表
+Ordered Quantity,訂購數量
+"e.g. ""Build tools for builders""",例如「建設建設者工具“
+Grading Scale Intervals,分級刻度間隔
+Purchase Defaults,購買默認值
+Make Job Card,製作工作卡
+"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again",無法自動創建Credit Note，請取消選中&#39;Issue Credit Note&#39;並再次提交
+Profit for the year,年度利潤
+{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}在{2}會計分錄只能在貨幣言：{3}
+In Process,在過程
+Itemwise Discount,Itemwise折扣
+Tree of financial accounts.,財務賬目的樹。
+Reference Document Type,參考文檔類型
+Cash Flow Mapping,現金流量映射
+{0} against Sales Order {1},{0}針對銷售訂單{1}
+Fixed Asset,固定資產
+After Date,日期之後
+Serialized Inventory,序列化庫存
+Invalid {0} for Inter Company Invoice.,Inter公司發票無效的{0}。
+Department Analytics,部門分析
+Email not found in default contact,在默認聯繫人中找不到電子郵件
+Account Info,帳戶信息
+Default Billing Rate,默認計費率
+{0} Student Groups created.,{0}創建學生組。
+{0} Student Groups created.,{0}創建學生組。
+Total Billing Amount,總結算金額
+Program in the Fee Structure and Student Group {0} are different.,費用結構和學生組{0}中的課程是不同的。
+Receivable Account,應收帳款
+Valid From Date must be lesser than Valid Upto Date.,有效起始日期必須小於有效起始日期。
+Row #{0}: Asset {1} is already {2},行＃{0}：資產{1}已經是{2}
+Stock Balance,庫存餘額
+Sales Order to Payment,銷售訂單到付款
+With Payment of Tax,繳納稅款
+Expense Claim Detail,報銷詳情
+TRIPLICATE FOR SUPPLIER,供應商提供服務
+New Balance In Base Currency,基礎貨幣的新平衡
+This will be day 1 of the crop cycle,這將是作物週期的第一天
+Please select correct account,請選擇正確的科目
+Salary Structure Assignment,薪酬結構分配
+Weight UOM,重量計量單位
+List of available Shareholders with folio numbers,包含folio號碼的可用股東名單
+Salary Structure Employee,薪資結構員工
+Show Variant Attributes,顯示變體屬性
+The payment gateway account in plan {0} is different from the payment gateway account in this payment request,計劃{0}中的支付閘道科目與此付款請求中的支付閘道科目不同
+Course Name,課程名
+No Tax Withholding data found for the current Fiscal Year.,未找到當前財年的預扣稅數據。
+Users who can approve a specific employee's leave applications,用戶可以批准特定員工的休假申請
+Office Equipments,辦公設備
+Qty,數量
+Companies,企業
+Scoring Setup,得分設置
+Electronics,電子
+Debit ({0}),借記卡（{0}）
+Allow Same Item Multiple Times,多次允許相同的項目
+Raise Material Request when stock reaches re-order level,當庫存到達需重新訂購水平時提高物料需求
+Full-time,全日制
+Employees,僱員
+Contact Details,聯絡方式
+Received Date,接收日期
+"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.",如果您已經創建了銷售稅和費模板標準模板，選擇一個，然後點擊下面的按鈕。
+Basic Amount (Company Currency),基本金額（公司幣種）
+Guardians,守護者
+Payment Confirmation,付款確認
+Prices will not be shown if Price List is not set,價格將不會顯示如果沒有設置價格
+Total Incoming Value,總收入值
+Debit To is required,借方是必填項
+Inpatient Record,住院病歷
+"Timesheets help keep track of time, cost and billing for activites done by your team",時間表幫助追踪的時間，費用和結算由你的團隊做activites,
+Purchase Price List,採購價格表
+Templates of supplier scorecard variables.,供應商記分卡變數模板。
+Offer Term,要約期限
+Quality Manager,質量經理
+Job Opening,開放職位
+Payment Reconciliation,付款對帳
+Please select Incharge Person's name,請選擇Incharge人的名字
+Technology,技術
+BOM Website Operation,BOM網站運營
+outstanding_amount,outstanding_amount,
+Supplier Score,供應商分數
+Schedule Admission,安排入場
+Cumulative Transaction Threshold,累積交易閾值
+Total Invoiced Amt,總開票金額
+Conversion Rate,兌換率
+Product Search,產品搜索
+To Time,要時間
+) for {0},）為{0}
+Approving Role (above authorized value),批准角色（上述授權值）
+Credit To account must be a Payable account,信用科目必須是應付帳款
+Total Amount Paid,總金額支付
+Insurance End Date,保險終止日期
+Please select Student Admission which is mandatory for the paid student applicant,請選擇付費學生申請者必須入學的學生
+BOM recursion: {0} cannot be parent or child of {2},BOM遞歸： {0}不能父母或兒童{2}
+Budget List,預算清單
+Completed Qty,完成數量
+"For {0}, only debit accounts can be linked against another credit entry",{0}，只有借方科目可以連接另一個貸方分錄
+Allow Overtime,允許加班
+"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry",序列化項目{0}無法使用庫存調節更新，請使用庫存條目
+"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry",序列化項目{0}無法使用庫存調節更新，請使用庫存條目
+Training Event Employee,培訓活動的員工
+Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,可以為批次{1}和項目{2}保留最大樣本數量{0}。
+Add Time Slots,添加時間插槽
+{0} Serial Numbers required for Item {1}. You have provided {2}.,{0}產品{1}需要的序號。您已提供{2}。
+Current Valuation Rate,目前的估值價格
+Advance,提前
+GoCardless payment gateway settings,GoCardless支付網關設置
+Exchange Gain/Loss,兌換收益/損失
+Lost Reason,失落的原因
+Enable Amazon,啟用亞馬遜
+Row #{0}: Account {1} does not belong to company {2},行＃{0}：科目{1}不屬於公司{2}
+Unable to find DocType {0},無法找到DocType {0}
+Sample Size,樣本大小
+Please enter Receipt Document,請輸入收據憑證
+All items have already been invoiced,所有項目已開具發票
+Please specify a valid 'From Case No.',請指定一個有效的“從案號”
+Further cost centers can be made under Groups but entries can be made against non-Groups,進一步的成本中心可以根據組進行，但項可以對非組進行
+Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,在此期間，總分配的離職時間超過員工{1}的最大分配{0}離職類型的天數
+Users and Permissions,用戶和權限
+Branch,分支機構
+Ca/(K+Ca+Mg),的Ca /（K +鈣+鎂）
+Fulfillment User,履行用戶
+Total Monthly Sales,每月銷售總額
+Subscription Plans,訂閱計劃
+Weather,天氣
+Actual Quantity,實際數量
+example: Next Day Shipping,例如：次日發貨
+Serial No {0} not found,序列號{0}未找到
+Fee Schedule Program,費用計劃計劃
+Student Batch,學生批
+Make Student,使學生
+Min Grade,最小成績
+Healthcare Service Unit Type,醫療服務單位類型
+You have been invited to collaborate on the project: {0},您已被邀請在項目上進行合作：{0}
+Parent Supplier Group,父供應商組
+Purchase Orders to Bill,向比爾購買訂單
+Accumulated Values in Group Company,集團公司累計價值
+Block Date,封鎖日期
+Supplier Delivery Note,供應商交貨單
+Apply Now,現在申請
+Type of Proof,證明類型
+Actual Qty {0} / Waiting Qty {1},實際數量{0} /等待數量{1}
+Actual Qty {0} / Waiting Qty {1},實際數量{0} /等待數量{1}
+E-commerce GSTIN,電子商務GSTIN,
+Bank Clearance Summary,銀行結算摘要
+"Create and manage daily, weekly and monthly email digests.",建立和管理每日，每週和每月的電子郵件摘要。
+This is based on transactions against this Sales Person. See timeline below for details,這是基於針對此銷售人員的交易。請參閱下面的時間表了解詳情
+Appraisal Goal,考核目標
+Current Amount,電流量
+Tax Declaration of {0} for period {1} already submitted.,已提交期間{1}的稅務申報{0}。
+Leaves has been granted sucessfully,葉子已成功獲得
+Fee Structure,費用結構
+Costing Amount,成本核算金額
+Application Fee,報名費
+Submit Salary Slip,提交工資單
+On Hold,等候接聽
+Inter Company Account,公司內帳戶
+Import in Bulk,進口散裝
+Address & Contacts,地址及聯絡方式
+Sender Name,發件人名稱
+Agriculture Analysis Criteria,農業分析標準
+Leave Approval Notification Template,留下批准通知模板
+[Select],[選擇]
+Number Of Positions,職位數
+Blood Pressure (diastolic),血壓（舒張）
+Sent To,發給
+Make Sales Invoice,做銷售發票
+Softwares,軟件
+Next Contact Date cannot be in the past,接下來跟日期不能過去
+For Reference Only.,僅供參考。
+Select Batch No,選擇批號
+Invalid {0}: {1},無效的{0}：{1}
+Reference Inv,參考文獻
+Advance Amount,提前量
+Capacity Planning,產能規劃
+Rounding Adjustment (Company Currency,四捨五入調整（公司貨幣）
+Policy number,保單號碼
+Reference Number,參考號碼
+New Workplace,新工作空間
+Retention Bonus,保留獎金
+Set as Closed,設置為關閉
+No Item with Barcode {0},沒有條碼{0}的品項
+Require Result Value,需要結果值
+Show a slideshow at the top of the page,顯示幻燈片在頁面頂部
+Tax Withholding Rate,稅收預扣稅率
+Boms,物料清單
+Stores,商店
+Projects Manager,項目經理
+Delivery Time,交貨時間
+Ageing Based On,老齡化基於
+Appointment cancelled,預約被取消
+End of Life,壽命結束
+Travel,旅遊
+Include All Assessment Group,包括所有評估小組
+No active or default Salary Structure found for employee {0} for the given dates,發現員工{0}對於給定的日期沒有活動或默認的薪酬結構
+Allow Users,允許用戶
+Customer Mobile No,客戶手機號碼
+Cash Flow Mapping Template Details,現金流量映射模板細節
+Loan Management,貸款管理
+Track separate Income and Expense for product verticals or divisions.,跟踪獨立收入和支出進行產品垂直或部門。
+Item Reorder,項目重新排序
+Show Salary Slip,顯示工資單
+Transfer Material,轉印材料
+Send Payment Request,發送付款請求
+"Specify the operations, operating cost and give a unique Operation no to your operations.",指定作業、作業成本並給予該作業一個專屬的作業編號。
+Any other details,任何其他細節
+This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,這份文件是超過限制，通過{0} {1}項{4}。你在做另一個{3}對同一{2}？
+Please set recurring after saving,請設置保存後復發
+Select change amount account,選擇變化量科目
+Price List Currency,價格表之貨幣
+User must always select,用戶必須始終選擇
+Allow Negative Stock,允許負庫存
+Installation Note,安裝注意事項
+Topic,話題
+Cash Flow from Financing,從融資現金流
+Budget Account,預算科目
+Verified By,認證機構
+Name of Organizer,主辦單位名稱
+"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.",不能改變公司的預設貨幣，因為有存在的交易。交易必須取消更改預設貨幣。
+Is Income Tax Liability,是所得稅責任
+Grade Description,等級說明
+Is Invoiced,已開票
+Purchase Receipt No,採購入庫單編號
+Earnest Money,保證金
+ Shipping Bill Number,裝運單編號
+Actions performed,已執行的操作
+Section Leader,科長
+Transport Receipt No,運輸收據編號
+Source of Funds (Liabilities),資金來源（負債）
+Source and Target Location cannot be same,源和目標位置不能相同
+Quantity in row {0} ({1}) must be same as manufactured quantity {2},列{0}的數量（{1}）必須與生產量{2}相同
+Employee,僱員
+Fixed Deposit Number,定期存款編號
+Failure Date,失敗日期
+Result Title Field,結果標題字段
+Collected Time,收集時間
+Sales Monthly History,銷售月曆
+Next Due Date,下一個到期日
+Select Batch,選擇批次
+{0} {1} is fully billed,{0} {1}}已開票
+Vital Signs,生命體徵
+Payment Deductions or Loss,付款扣除或損失
+Soil Analysis Criterias,土壤分析標準
+Standard contract terms for Sales or Purchase.,銷售或採購的標準合同條款。
+Group by Voucher,集團透過券
+Are you sure you want to cancel this appointment?,你確定要取消這個預約嗎？
+Hotel Room Pricing Package,酒店房間價格套餐
+Sales Pipeline,銷售渠道
+Please set default account in Salary Component {0},請薪酬部分設置默認科目{0}
+Please select BOM for Item in Row {0},請行選擇BOM為項目{0}
+Fetch Subscription Updates,獲取訂閱更新
+Account {0} does not match with Company {1} in Mode of Account: {2},帳戶{0}與帳戶模式{2}中的公司{1}不符
+Specified BOM {0} does not exist for Item {1},指定BOM {0}的項目不存在{1}
+Course: ,課程：
+Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,維護時間表{0}必須取消早於取消這個銷售訂單
+Applicable for Users,適用於用戶
+Expense Claim Approved,報銷批准
+Set Advances and Allocate (FIFO),設置進度和分配（FIFO）
+No Work Orders created,沒有創建工作訂單
+Salary Slip of employee {0} already created for this period,員工的工資單{0}已為這一時期創建
+Pharmaceutical,製藥
+You can only submit Leave Encashment for a valid encashment amount,您只能提交離開封存以獲得有效的兌換金額
+Cost of Purchased Items,購買的物品成本
+Employee Separation Template,員工分離模板
+Sales Order Required,銷售訂單需求
+Become a Seller,成為賣家
+Credit To,信貸
+Active Leads / Customers,有效訊息/客戶
+Leave blank to use the standard Delivery Note format,留空以使用標準的交貨單格式
+Maintenance Schedule Detail,維護計劃細節
+Warn for new Purchase Orders,警告新的採購訂單
+Reading 9,9閱讀
+Is Frozen,就是冰凍
+Group node warehouse is not allowed to select for transactions,組節點倉庫不允許選擇用於交易
+Buying Settings,採購設定
+BOM No. for a Finished Good Item,BOM編號為成品產品
+Attendance To Date,出席會議日期
+No Quote,沒有報價
+Post Title Key,帖子標題密鑰
+For Job Card,對於工作卡
+Prescriptions,處方
+Payment Account,付款帳號
+Please specify Company to proceed,請註明公司以處理
+Net Change in Accounts Receivable,應收帳款淨額變化
+Compensatory Off,補假
+Accepted,接受的
+Sales Invoices Summary,銷售發票摘要
+To Party Name,到黨名
+Organization,組織
+Organization,組織
+BOM Update Tool,BOM更新工具
+Student Group Name,學生組名稱
+Show exploded view,顯示爆炸視圖
+Creating Fees,創造費用
+Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,請確保你真的要刪除這家公司的所有交易。主數據將保持原樣。這個動作不能撤消。
+Search Results,搜索結果
+Room Number,房間號
+Invalid reference {0} {1},無效的參考{0} {1}
+{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},"{0} ({1})不能大於計劃數量
 ({2})生產訂單的 {3}"
-DocType: Shipping Rule,Shipping Rule Label,送貨規則標籤
-DocType: Journal Entry Account,Payroll Entry,工資項目
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +76,View Fees Records,查看費用記錄
-apps/erpnext/erpnext/setup/doctype/company/company.js +55,Make Tax Template,使稅收模板
-apps/erpnext/erpnext/public/js/conf.js +28,User Forum,用戶論壇
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +333,Raw Materials cannot be blank.,原材料不能為空。
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1029,Row #{0} (Payment Table): Amount must be negative,行＃{0}（付款表）：金額必須為負數
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +570,"Could not update stock, invoice contains drop shipping item.",無法更新庫存，發票包含下降航運項目。
-DocType: Contract,Fulfilment Status,履行狀態
-DocType: Lab Test Sample,Lab Test Sample,實驗室測試樣品
-DocType: Item Variant Settings,Allow Rename Attribute Value,允許重命名屬性值
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +533,Quick Journal Entry,快速日記帳分錄
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +244,You can not change rate if BOM mentioned agianst any item,你不能改變速度，如果BOM中提到反對的任何項目
-DocType: Restaurant,Invoice Series Prefix,發票系列前綴
-DocType: Employee,Previous Work Experience,以前的工作經驗
-apps/erpnext/erpnext/accounts/doctype/account/account.js +140,Update Account Number / Name,更新帳號/名稱
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +413,Assign Salary Structure,分配薪資結構
-DocType: Support Settings,Response Key List,響應密鑰列表
-DocType: Job Card,For Quantity,對於數量
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205,Please enter Planned Qty for Item {0} at row {1},請輸入列{1}的品項{0}的計劃數量
-DocType: Support Search Source,API,API
-DocType: Support Search Source,Result Preview Field,結果預覽字段
-DocType: Item Price,Packing Unit,包裝單位
-DocType: Subscription,Trialling,試用
-DocType: Sales Invoice Item,Deferred Revenue,遞延收入
-DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,現金科目將用於創建銷售發票
-DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,豁免子類別
-DocType: Member,Membership Expiry Date,會員到期日
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +134,{0} must be negative in return document,{0}必須返回文檔中負
-,Minutes to First Response for Issues,分鐘的問題第一個反應
-DocType: Purchase Invoice,Terms and Conditions1,條款及條件1
-apps/erpnext/erpnext/public/js/setup_wizard.js +109,The name of the institute for which you are setting up this system.,該機構的名稱要為其建立這個系統。
-DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.",會計分錄凍結至該日期，除以下指定職位權限外，他人無法修改。
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116,Please save the document before generating maintenance schedule,請在產生維護計畫前儲存文件
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +45,Latest price updated in all BOMs,最新價格在所有BOM中更新
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,項目狀態
-DocType: UOM,Check this to disallow fractions. (for Nos),勾選此選項則禁止分數。 （對於NOS）
-DocType: Student Admission Program,Naming Series (for Student Applicant),命名系列（面向學生申請人）
-apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py +16,Bonus Payment Date cannot be a past date,獎金支付日期不能是過去的日期
-DocType: Travel Request,Copy of Invitation/Announcement,邀請/公告的副本
-DocType: Practitioner Service Unit Schedule,Practitioner Service Unit Schedule,從業者服務單位時間表
-DocType: Delivery Note,Transporter Name,貨運公司名稱
-DocType: Authorization Rule,Authorized Value,授權值
-DocType: BOM,Show Operations,顯示操作
-,Minutes to First Response for Opportunity,分鐘的機會第一個反應
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +97,Total Absent,共缺席
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1064,Item or Warehouse for row {0} does not match Material Request,行{0}的項目或倉庫不符合物料需求
-apps/erpnext/erpnext/config/stock.py +194,Unit of Measure,計量單位
-DocType: Fiscal Year,Year End Date,年結結束日期
-DocType: Task Depends On,Task Depends On,任務取決於
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1083,Opportunity,機會
-DocType: Operation,Default Workstation,預設工作站
-DocType: Notification Control,Expense Claim Approved Message,報銷批准的訊息
-DocType: Payment Entry,Deductions or Loss,扣除或損失
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +279,{0} {1} is closed,{0} {1}關閉
-DocType: Email Digest,How frequently?,多久？
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +56,Total Collected: {0},總計：{0}
-DocType: Purchase Receipt,Get Current Stock,取得當前庫存資料
-apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,物料清單樹狀圖
-DocType: Student,Joining Date,入職日期
-,Employees working on a holiday,員工在假期工作
-,TDS Computation Summary,TDS計算摘要
-DocType: Share Balance,Current State,當前狀態
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,馬克現在
-DocType: Share Transfer,From Shareholder,來自股東
-apps/erpnext/erpnext/healthcare/setup.py +180,Drug,藥物
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200,Maintenance start date can not be before delivery date for Serial No {0},序號{0}的維護開始日期不能早於交貨日期
-DocType: Job Card,Actual End Date,實際結束日期
-DocType: Cash Flow Mapping,Is Finance Cost Adjustment,財務成本調整
-DocType: BOM,Operating Cost (Company Currency),營業成本（公司貨幣）
-DocType: Authorization Rule,Applicable To (Role),適用於（角色）
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +10,Pending Leaves,等待葉子
-DocType: BOM Update Tool,Replace BOM,更換BOM
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +113,Code {0} already exist,代碼{0}已經存在
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +37,Sales orders are not available for production,銷售訂單不可用於生產
-DocType: Company,Fixed Asset Depreciation Settings,固定資產折舊設置
-DocType: Item,Will also apply for variants unless overrridden,同時將申請變種，除非overrridden
-DocType: Purchase Invoice,Advances,進展
-DocType: Work Order,Manufacture against Material Request,對製造材料要求
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +17,Assessment Group: ,評估組：
-DocType: Item Reorder,Request for,要求
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,批准用戶作為用戶的規則適用於不能相同
-DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),基本速率（按庫存計量單位）
-DocType: SMS Log,No of Requested SMS,無的請求短信
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +328,Leave Without Pay does not match with approved Leave Application records,停薪留職不批准請假的記錄相匹配
-DocType: Travel Request,Domestic,國內
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +853,Please supply the specified items at the best possible rates,請在提供最好的利率規定的項目
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py +19,Employee Transfer cannot be submitted before Transfer Date ,員工轉移無法在轉移日期前提交
-apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.js +7,Make Invoice,製作發票
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +130,Remaining Balance,保持平衡
-DocType: Selling Settings,Auto close Opportunity after 15 days,15天之後自動關閉商機
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +83,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,由於{1}的記分卡，{0}不允許採購訂單。
-apps/erpnext/erpnext/stock/doctype/item/item.py +529,Barcode {0} is not a valid {1} code,條形碼{0}不是有效的{1}代碼
-apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js +25,End Year,結束年份
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,報價/鉛％
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,報價/鉛％
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +141,Contract End Date must be greater than Date of Joining,合同結束日期必須大於加入的日期
-DocType: Driver,Driver,司機
-DocType: Vital Signs,Nutrition Values,營養價值觀
-DocType: Lab Test Template,Is billable,是可計費的
-DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,第三方分銷商/經銷商/代理商/分支機構/分銷商誰銷售公司產品的佣金。
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +412,{0} against Purchase Order {1},{0}針對採購訂單{1}
-DocType: Patient,Patient Demographics,患者人口統計學
-DocType: Task,Actual Start Date (via Time Sheet),實際開始日期（通過時間表）
-apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15,This is an example website auto-generated from ERPNext,這是一個由 ERPNext 自動產生的範例網站
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +28,Ageing Range 1,老齡範圍1
-DocType: Shopify Settings,Enable Shopify,啟用Shopify
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +220,Total advance amount cannot be greater than total claimed amount,總預付金額不能超過索賠總額
-DocType: Purchase Taxes and Charges Template,"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
+Shipping Rule Label,送貨規則標籤
+Payroll Entry,工資項目
+View Fees Records,查看費用記錄
+Make Tax Template,使稅收模板
+User Forum,用戶論壇
+Raw Materials cannot be blank.,原材料不能為空。
+Row #{0} (Payment Table): Amount must be negative,行＃{0}（付款表）：金額必須為負數
+"Could not update stock, invoice contains drop shipping item.",無法更新庫存，發票包含下降航運項目。
+Fulfilment Status,履行狀態
+Lab Test Sample,實驗室測試樣品
+Allow Rename Attribute Value,允許重命名屬性值
+Quick Journal Entry,快速日記帳分錄
+You can not change rate if BOM mentioned agianst any item,你不能改變速度，如果BOM中提到反對的任何項目
+Invoice Series Prefix,發票系列前綴
+Previous Work Experience,以前的工作經驗
+Update Account Number / Name,更新帳號/名稱
+Assign Salary Structure,分配薪資結構
+Response Key List,響應密鑰列表
+For Quantity,對於數量
+Please enter Planned Qty for Item {0} at row {1},請輸入列{1}的品項{0}的計劃數量
+API,API,
+Result Preview Field,結果預覽字段
+Packing Unit,包裝單位
+Trialling,試用
+Deferred Revenue,遞延收入
+Cash Account will used for Sales Invoice creation,現金科目將用於創建銷售發票
+Exemption Sub Category,豁免子類別
+Membership Expiry Date,會員到期日
+{0} must be negative in return document,{0}必須返回文檔中負
+Minutes to First Response for Issues,分鐘的問題第一個反應
+Terms and Conditions1,條款及條件1,
+The name of the institute for which you are setting up this system.,該機構的名稱要為其建立這個系統。
+"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.",會計分錄凍結至該日期，除以下指定職位權限外，他人無法修改。
+Please save the document before generating maintenance schedule,請在產生維護計畫前儲存文件
+Latest price updated in all BOMs,最新價格在所有BOM中更新
+Project Status,項目狀態
+Check this to disallow fractions. (for Nos),勾選此選項則禁止分數。 （對於NOS）
+Naming Series (for Student Applicant),命名系列（面向學生申請人）
+Bonus Payment Date cannot be a past date,獎金支付日期不能是過去的日期
+Copy of Invitation/Announcement,邀請/公告的副本
+Practitioner Service Unit Schedule,從業者服務單位時間表
+Transporter Name,貨運公司名稱
+Authorized Value,授權值
+Show Operations,顯示操作
+Minutes to First Response for Opportunity,分鐘的機會第一個反應
+Total Absent,共缺席
+Item or Warehouse for row {0} does not match Material Request,行{0}的項目或倉庫不符合物料需求
+Unit of Measure,計量單位
+Year End Date,年結結束日期
+Task Depends On,任務取決於
+Opportunity,機會
+Default Workstation,預設工作站
+Expense Claim Approved Message,報銷批准的訊息
+Deductions or Loss,扣除或損失
+{0} {1} is closed,{0} {1}關閉
+How frequently?,多久？
+Total Collected: {0},總計：{0}
+Get Current Stock,取得當前庫存資料
+Tree of Bill of Materials,物料清單樹狀圖
+Joining Date,入職日期
+Employees working on a holiday,員工在假期工作
+TDS Computation Summary,TDS計算摘要
+Current State,當前狀態
+Mark Present,馬克現在
+From Shareholder,來自股東
+Drug,藥物
+Maintenance start date can not be before delivery date for Serial No {0},序號{0}的維護開始日期不能早於交貨日期
+Actual End Date,實際結束日期
+Is Finance Cost Adjustment,財務成本調整
+Operating Cost (Company Currency),營業成本（公司貨幣）
+Applicable To (Role),適用於（角色）
+Pending Leaves,等待葉子
+Replace BOM,更換BOM,
+Code {0} already exist,代碼{0}已經存在
+Sales orders are not available for production,銷售訂單不可用於生產
+Fixed Asset Depreciation Settings,固定資產折舊設置
+Will also apply for variants unless overrridden,同時將申請變種，除非overrridden,
+Advances,進展
+Manufacture against Material Request,對製造材料要求
+Assessment Group: ,評估組：
+Request for,要求
+Approving User cannot be same as user the rule is Applicable To,批准用戶作為用戶的規則適用於不能相同
+Basic Rate (as per Stock UOM),基本速率（按庫存計量單位）
+No of Requested SMS,無的請求短信
+Leave Without Pay does not match with approved Leave Application records,停薪留職不批准請假的記錄相匹配
+Domestic,國內
+Please supply the specified items at the best possible rates,請在提供最好的利率規定的項目
+Employee Transfer cannot be submitted before Transfer Date ,員工轉移無法在轉移日期前提交
+Make Invoice,製作發票
+Remaining Balance,保持平衡
+Auto close Opportunity after 15 days,15天之後自動關閉商機
+Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,由於{1}的記分卡，{0}不允許採購訂單。
+Barcode {0} is not a valid {1} code,條形碼{0}不是有效的{1}代碼
+End Year,結束年份
+Quot/Lead %,報價/鉛％
+Quot/Lead %,報價/鉛％
+Contract End Date must be greater than Date of Joining,合同結束日期必須大於加入的日期
+Driver,司機
+Nutrition Values,營養價值觀
+Is billable,是可計費的
+A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,第三方分銷商/經銷商/代理商/分支機構/分銷商誰銷售公司產品的佣金。
+{0} against Purchase Order {1},{0}針對採購訂單{1}
+Patient Demographics,患者人口統計學
+Actual Start Date (via Time Sheet),實際開始日期（通過時間表）
+This is an example website auto-generated from ERPNext,這是一個由 ERPNext 自動產生的範例網站
+Ageing Range 1,老齡範圍1,
+Enable Shopify,啟用Shopify,
+Total advance amount cannot be greater than total claimed amount,總預付金額不能超過索賠總額
+"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
 
-#### Note
+#### Note,
 
 The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.
 
-#### Description of Columns
+#### Description of Columns,
 
 1. Calculation Type: 
     - This can be on **Net Total** (that is the sum of basic amount).
     - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
     - **Actual** (as mentioned).
-2. Account Head: The Account ledger under which this tax will be booked
+2. Account Head: The Account ledger under which this tax will be booked,
 3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
 4. Description: Description of the tax (that will be printed in invoices / quotes).
 5. Rate: Tax rate.
@@ -3349,287 +3349,287 @@
  8。輸入行：如果基於“前行匯總”，您可以選擇將被視為這種計算基礎（預設值是前行）的行號。
  9。考慮稅收或收費為：在本節中，你可以指定是否稅/費僅用於評估（總不是部分），或只為總（不增加價值的項目），或兩者兼有。
  10。添加或扣除：無論你是想增加或扣除的稅。"
-DocType: Homepage,Homepage,主頁
-DocType: Grant Application,Grant Application Details ,授予申請細節
-DocType: Employee Separation,Employee Separation,員工分離
-DocType: BOM Item,Original Item,原始項目
-DocType: Purchase Receipt Item,Recd Quantity,到貨數量
-apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +64,Fee Records Created - {0},費紀錄創造 -  {0}
-DocType: Asset Category Account,Asset Category Account,資產類別的科目
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1024,Row #{0} (Payment Table): Amount must be positive,行＃{0}（付款表）：金額必須為正值
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +137,Cannot produce more Item {0} than Sales Order quantity {1},無法產生更多的項目{0}不是銷售訂單數量{1}
-apps/erpnext/erpnext/stock/doctype/item/item.js +446,Select Attribute Values,選擇屬性值
-DocType: Purchase Invoice,Reason For Issuing document,簽發文件的原因
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +583,Stock Entry {0} is not submitted,庫存輸入{0}不提交
-DocType: Payment Reconciliation,Bank / Cash Account,銀行／現金科目
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +47,Next Contact By cannot be same as the Lead Email Address,接著聯繫到不能相同鉛郵箱地址
-DocType: Tax Rule,Billing City,結算城市
-DocType: Asset,Manual,手冊
-DocType: Salary Component Account,Salary Component Account,薪金部分科目
-DocType: Global Defaults,Hide Currency Symbol,隱藏貨幣符號
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +281,Sales Opportunities by Source,來源的銷售機會
-apps/erpnext/erpnext/config/accounts.py +287,"e.g. Bank, Cash, Credit Card",例如：銀行，現金，信用卡
-DocType: Job Applicant,Source Name,源名稱
-DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""",成年人的正常靜息血壓約為收縮期120mmHg，舒張壓80mmHg，縮寫為“120 / 80mmHg”
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +124,"Set items shelf life in days, to set expiry based on manufacturing_date plus self life",以天為單位設置貨架保質期，根據manufacturer_date加上自我壽命設置到期日
-DocType: Journal Entry,Credit Note,信用票據
-DocType: Projects Settings,Ignore Employee Time Overlap,忽略員工時間重疊
-DocType: Warranty Claim,Service Address,服務地址
-DocType: Asset Maintenance Task,Calibration,校準
-apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py +19,Leave Status Notification,離開狀態通知
-DocType: Patient Appointment,Procedure Prescription,程序處方
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +50,Furnitures and Fixtures,家具及固定裝置
-DocType: Travel Request,Travel Type,旅行類型
-DocType: Item,Manufacture,製造
-apps/erpnext/erpnext/utilities/user_progress.py +27,Setup Company,安裝公司
-,Lab Test Report,實驗室測試報告
-DocType: Employee Benefit Application,Employee Benefit Application,員工福利申請
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,請送貨單第一
-DocType: Student Applicant,Application Date,申請日期
-DocType: Salary Component,Amount based on formula,量基於式
-DocType: Purchase Invoice,Currency and Price List,貨幣和價格表
-DocType: Opportunity,Customer / Lead Name,客戶/鉛名稱
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +115,Clearance Date not mentioned,清拆日期未提及
-DocType: Payroll Period,Taxable Salary Slabs,應稅薪金板塊
-apps/erpnext/erpnext/config/manufacturing.py +7,Production,生產
-DocType: Guardian,Occupation,佔用
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +210,For Quantity must be less than quantity {0},對於數量必須小於數量{0}
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74,Row {0}:Start Date must be before End Date,列#{0}：開始日期必須早於結束日期
-DocType: Salary Component,Max Benefit Amount (Yearly),最大福利金額（每年）
-DocType: Crop,Planting Area,種植面積
-apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),總計（數量）
-DocType: Installation Note Item,Installed Qty,安裝數量
-apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10,Training Result,訓練結果
-DocType: Purchase Invoice,Is Paid,支付
-DocType: Salary Structure,Total Earning,總盈利
-DocType: Purchase Receipt,Time at which materials were received,物料收到的時間
-DocType: Products Settings,Products per Page,每頁產品
-DocType: Stock Ledger Entry,Outgoing Rate,傳出率
-DocType: Sales Order,Billing Status,計費狀態
-apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,報告問題
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +127,Utility Expenses,公用事業費用
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +253,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,行＃{0}：日記條目{1}沒有帳戶{2}或已經對另一憑證匹配
-DocType: Supplier Scorecard Criteria,Criteria Weight,標準重量
-apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py +7,Leave Approval Notification,留下批准通知
-DocType: Buying Settings,Default Buying Price List,預設採購價格表
-DocType: Payroll Entry,Salary Slip Based on Timesheet,基於時間表工資單
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +55,Buying Rate,購買率
-apps/erpnext/erpnext/controllers/buying_controller.py +602,Row {0}: Enter location for the asset item {1},行{0}：輸入資產項目{1}的位置
-DocType: Company,About the Company,關於公司
-DocType: Notification Control,Sales Order Message,銷售訂單訊息
-apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.",設定預設值如公司，貨幣，當前財政年度等
-DocType: Payment Entry,Payment Type,付款類型
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +245,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,請選擇項目{0}的批次。無法找到滿足此要求的單個批次
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +245,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,請選擇項目{0}的批次。無法找到滿足此要求的單個批次
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1184,No gain or loss in the exchange rate,匯率沒有收益或損失
-DocType: Payroll Entry,Select Employees,選擇僱員
-DocType: Shopify Settings,Sales Invoice Series,銷售發票系列
-DocType: Opportunity,Potential Sales Deal,潛在的銷售交易
-DocType: Complaint,Complaints,投訴
-DocType: Employee Tax Exemption Declaration,Employee Tax Exemption Declaration,僱員免稅聲明
-DocType: Payment Entry,Cheque/Reference Date,支票/參考日期
-DocType: Purchase Invoice,Total Taxes and Charges,總營業稅金及費用
-DocType: Employee,Emergency Contact,緊急聯絡人
-DocType: Bank Reconciliation Detail,Payment Entry,付款輸入
-,sales-browser,銷售瀏覽器
-apps/erpnext/erpnext/accounts/doctype/account/account.js +78,Ledger,分類帳
-DocType: Drug Prescription,Drug Code,藥品代碼
-DocType: Target Detail,Target  Amount,目標金額
-DocType: POS Profile,Print Format for Online,在線打印格式
-DocType: Shopping Cart Settings,Shopping Cart Settings,購物車設定
-DocType: Journal Entry,Accounting Entries,會計分錄
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.",如果選定的定價規則是針對“費率”制定的，則會覆蓋價目表。定價規則費率是最終費率，因此不應再應用更多折扣。因此，在諸如銷售訂單，採購訂單等交易中，它將在&#39;費率&#39;字段中取代，而不是在&#39;價格列表率&#39;字段中取出。
-DocType: Journal Entry,Paid Loan,付費貸款
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},重複的條目。請檢查授權規則{0}
-DocType: Journal Entry Account,Reference Due Date,參考到期日
-DocType: Purchase Order,Ref SQ,參考SQ
-DocType: Leave Type,Applicable After (Working Days),適用於（工作日）
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Receipt document must be submitted,收到文件必須提交
-DocType: Purchase Invoice Item,Received Qty,到貨數量
-DocType: Stock Entry Detail,Serial No / Batch,序列號/批次
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +359,Not Paid and Not Delivered,沒有支付，未送達
-DocType: Product Bundle,Parent Item,父項目
-DocType: Account,Account Type,科目類型
-DocType: Shopify Settings,Webhooks Details,Webhooks詳細信息
-apps/erpnext/erpnext/templates/pages/projects.html +58,No time sheets,沒有考勤表
-DocType: GoCardless Mandate,GoCardless Customer,GoCardless客戶
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +160,Leave Type {0} cannot be carry-forwarded,休假類型{0}不能隨身轉發
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',維護計畫不會為全部品項生成。請點擊“生成表”
-,To Produce,以生產
-DocType: Leave Encashment,Payroll,工資表
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +209,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included",對於行{0} {1}。以包括{2}中的檔案速率，行{3}也必須包括
-DocType: Healthcare Service Unit,Parent Service Unit,家長服務單位
-apps/erpnext/erpnext/utilities/activation.py +101,Make User,使用戶
-DocType: Packing Slip,Identification of the package for the delivery (for print),寄送包裹的識別碼（用於列印）
-DocType: Bin,Reserved Quantity,保留數量
-apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,請輸入有效的電子郵件地址
-apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,請輸入有效的電子郵件地址
-DocType: Volunteer Skill,Volunteer Skill,志願者技能
-DocType: Purchase Invoice,Inter Company Invoice Reference,Inter公司發票參考
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +883,Please select an item in the cart,請在購物車中選擇一個項目
-DocType: Landed Cost Voucher,Purchase Receipt Items,採購入庫項目
-apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,自定義表單
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +52,Arrear,拖欠
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +173,Depreciation Amount during the period,期間折舊額
-DocType: Sales Invoice,Is Return (Credit Note),是退貨（信用票據）
-apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js +26,Start Job,開始工作
-apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +32,Serial no is required for the asset {0},資產{0}需要序列號
-apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43,Disabled template must not be default template,殘疾人模板必須不能默認模板
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +542,For row {0}: Enter planned qty,對於行{0}：輸入計劃的數量
-DocType: Account,Income Account,收入科目
-DocType: Payment Request,Amount in customer's currency,量客戶的貨幣
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +880,Delivery,交貨
-DocType: Stock Reconciliation Item,Current Qty,目前數量
-DocType: Restaurant Menu,Restaurant Menu,餐廳菜單
-apps/erpnext/erpnext/public/js/event.js +23,Add Suppliers,添加供應商
-DocType: Loyalty Program,Help Section,幫助科
-apps/erpnext/erpnext/templates/generators/item_group.html +26,Prev,上一頁
-DocType: Appraisal Goal,Key Responsibility Area,關鍵責任區
-DocType: Delivery Trip,Distance UOM,距離UOM
-apps/erpnext/erpnext/utilities/activation.py +127,"Student Batches help you track attendance, assessments and fees for students",學生批幫助您跟踪學生的出勤，評估和費用
-DocType: Payment Entry,Total Allocated Amount,總撥款額
-apps/erpnext/erpnext/setup/doctype/company/company.py +163,Set default inventory account for perpetual inventory,設置永久庫存的默認庫存科目
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +261,"Cannot deliver Serial No {0} of item {1} as it is reserved to \
+Homepage,主頁
+Grant Application Details ,授予申請細節
+Employee Separation,員工分離
+Original Item,原始項目
+Recd Quantity,到貨數量
+Fee Records Created - {0},費紀錄創造 -  {0}
+Asset Category Account,資產類別的科目
+Row #{0} (Payment Table): Amount must be positive,行＃{0}（付款表）：金額必須為正值
+Cannot produce more Item {0} than Sales Order quantity {1},無法產生更多的項目{0}不是銷售訂單數量{1}
+Select Attribute Values,選擇屬性值
+Reason For Issuing document,簽發文件的原因
+Stock Entry {0} is not submitted,庫存輸入{0}不提交
+Bank / Cash Account,銀行／現金科目
+Next Contact By cannot be same as the Lead Email Address,接著聯繫到不能相同鉛郵箱地址
+Billing City,結算城市
+Manual,手冊
+Salary Component Account,薪金部分科目
+Hide Currency Symbol,隱藏貨幣符號
+Sales Opportunities by Source,來源的銷售機會
+"e.g. Bank, Cash, Credit Card",例如：銀行，現金，信用卡
+Source Name,源名稱
+"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""",成年人的正常靜息血壓約為收縮期120mmHg，舒張壓80mmHg，縮寫為“120 / 80mmHg”
+"Set items shelf life in days, to set expiry based on manufacturing_date plus self life",以天為單位設置貨架保質期，根據manufacturer_date加上自我壽命設置到期日
+Credit Note,信用票據
+Ignore Employee Time Overlap,忽略員工時間重疊
+Service Address,服務地址
+Calibration,校準
+Leave Status Notification,離開狀態通知
+Procedure Prescription,程序處方
+Furnitures and Fixtures,家具及固定裝置
+Travel Type,旅行類型
+Manufacture,製造
+Setup Company,安裝公司
+Lab Test Report,實驗室測試報告
+Employee Benefit Application,員工福利申請
+Please Delivery Note first,請送貨單第一
+Application Date,申請日期
+Amount based on formula,量基於式
+Currency and Price List,貨幣和價格表
+Customer / Lead Name,客戶/鉛名稱
+Clearance Date not mentioned,清拆日期未提及
+Taxable Salary Slabs,應稅薪金板塊
+Production,生產
+Occupation,佔用
+For Quantity must be less than quantity {0},對於數量必須小於數量{0}
+Row {0}:Start Date must be before End Date,列#{0}：開始日期必須早於結束日期
+Max Benefit Amount (Yearly),最大福利金額（每年）
+Planting Area,種植面積
+Total(Qty),總計（數量）
+Installed Qty,安裝數量
+Training Result,訓練結果
+Is Paid,支付
+Total Earning,總盈利
+Time at which materials were received,物料收到的時間
+Products per Page,每頁產品
+Outgoing Rate,傳出率
+Billing Status,計費狀態
+Report an Issue,報告問題
+Utility Expenses,公用事業費用
+Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,行＃{0}：日記條目{1}沒有帳戶{2}或已經對另一憑證匹配
+Criteria Weight,標準重量
+Leave Approval Notification,留下批准通知
+Default Buying Price List,預設採購價格表
+Salary Slip Based on Timesheet,基於時間表工資單
+Buying Rate,購買率
+Row {0}: Enter location for the asset item {1},行{0}：輸入資產項目{1}的位置
+About the Company,關於公司
+Sales Order Message,銷售訂單訊息
+"Set Default Values like Company, Currency, Current Fiscal Year, etc.",設定預設值如公司，貨幣，當前財政年度等
+Payment Type,付款類型
+Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,請選擇項目{0}的批次。無法找到滿足此要求的單個批次
+Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,請選擇項目{0}的批次。無法找到滿足此要求的單個批次
+No gain or loss in the exchange rate,匯率沒有收益或損失
+Select Employees,選擇僱員
+Sales Invoice Series,銷售發票系列
+Potential Sales Deal,潛在的銷售交易
+Complaints,投訴
+Employee Tax Exemption Declaration,僱員免稅聲明
+Cheque/Reference Date,支票/參考日期
+Total Taxes and Charges,總營業稅金及費用
+Emergency Contact,緊急聯絡人
+Payment Entry,付款輸入
+sales-browser,銷售瀏覽器
+Ledger,分類帳
+Drug Code,藥品代碼
+Target  Amount,目標金額
+Print Format for Online,在線打印格式
+Shopping Cart Settings,購物車設定
+Accounting Entries,會計分錄
+"If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.",如果選定的定價規則是針對“費率”制定的，則會覆蓋價目表。定價規則費率是最終費率，因此不應再應用更多折扣。因此，在諸如銷售訂單，採購訂單等交易中，它將在&#39;費率&#39;字段中取代，而不是在&#39;價格列表率&#39;字段中取出。
+Paid Loan,付費貸款
+Duplicate Entry. Please check Authorization Rule {0},重複的條目。請檢查授權規則{0}
+Reference Due Date,參考到期日
+Ref SQ,參考SQ,
+Applicable After (Working Days),適用於（工作日）
+Receipt document must be submitted,收到文件必須提交
+Received Qty,到貨數量
+Serial No / Batch,序列號/批次
+Not Paid and Not Delivered,沒有支付，未送達
+Parent Item,父項目
+Account Type,科目類型
+Webhooks Details,Webhooks詳細信息
+No time sheets,沒有考勤表
+GoCardless Customer,GoCardless客戶
+Leave Type {0} cannot be carry-forwarded,休假類型{0}不能隨身轉發
+Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',維護計畫不會為全部品項生成。請點擊“生成表”
+To Produce,以生產
+Payroll,工資表
+"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included",對於行{0} {1}。以包括{2}中的檔案速率，行{3}也必須包括
+Parent Service Unit,家長服務單位
+Make User,使用戶
+Identification of the package for the delivery (for print),寄送包裹的識別碼（用於列印）
+Reserved Quantity,保留數量
+Please enter valid email address,請輸入有效的電子郵件地址
+Please enter valid email address,請輸入有效的電子郵件地址
+Volunteer Skill,志願者技能
+Inter Company Invoice Reference,Inter公司發票參考
+Please select an item in the cart,請在購物車中選擇一個項目
+Purchase Receipt Items,採購入庫項目
+Customizing Forms,自定義表單
+Arrear,拖欠
+Depreciation Amount during the period,期間折舊額
+Is Return (Credit Note),是退貨（信用票據）
+Start Job,開始工作
+Serial no is required for the asset {0},資產{0}需要序列號
+Disabled template must not be default template,殘疾人模板必須不能默認模板
+For row {0}: Enter planned qty,對於行{0}：輸入計劃的數量
+Income Account,收入科目
+Amount in customer's currency,量客戶的貨幣
+Delivery,交貨
+Current Qty,目前數量
+Restaurant Menu,餐廳菜單
+Add Suppliers,添加供應商
+Help Section,幫助科
+Prev,上一頁
+Key Responsibility Area,關鍵責任區
+Distance UOM,距離UOM,
+"Student Batches help you track attendance, assessments and fees for students",學生批幫助您跟踪學生的出勤，評估和費用
+Total Allocated Amount,總撥款額
+Set default inventory account for perpetual inventory,設置永久庫存的默認庫存科目
+"Cannot deliver Serial No {0} of item {1} as it is reserved to \
 												fullfill Sales Order {2}",無法提供項目{1}的序列號{0}，因為它保留在\ fullfill銷售訂單{2}中
-DocType: Item Reorder,Material Request Type,材料需求類型
-apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17,Send Grant Review Email,發送格蘭特回顧郵件
-apps/erpnext/erpnext/accounts/page/pos/pos.js +859,"LocalStorage is full, did not save",localStorage的是滿的，沒救
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +130,Row {0}: UOM Conversion Factor is mandatory,行{0}：計量單位轉換係數是必需的
-DocType: Employee Benefit Claim,Claim Date,索賠日期
-apps/erpnext/erpnext/utilities/user_progress.py +235,Room Capacity,房間容量
-apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py +28,Already record exists for the item {0},已有記錄存在項目{0}
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +28,Ref,參考
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +48,You will lose records of previously generated invoices. Are you sure you want to restart this subscription?,您將失去先前生成的發票記錄。您確定要重新啟用此訂閱嗎？
-DocType: Healthcare Settings,Registration Fee,註冊費用
-DocType: Loyalty Program Collection,Loyalty Program Collection,忠誠度計劃集
-DocType: Stock Entry Detail,Subcontracted Item,轉包項目
-apps/erpnext/erpnext/education/__init__.py +9,Student {0} does not belong to group {1},學生{0}不屬於組{1}
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +57,Voucher #,憑證＃
-DocType: Notification Control,Purchase Order Message,採購訂單的訊息
-DocType: Tax Rule,Shipping Country,航運國家
-DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,從銷售交易隱藏客戶的稅號
-DocType: Upload Attendance,Upload HTML,上傳HTML
-DocType: Employee,Relieving Date,解除日期
-DocType: Purchase Invoice,Total Quantity,總數（量
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.",定價規則是由覆蓋價格表/定義折扣百分比，基於某些條件。
-DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,倉庫只能通過存貨分錄/送貨單/採購入庫單來改變
-DocType: Employee Education,Class / Percentage,類／百分比
-DocType: Shopify Settings,Shopify Settings,Shopify設置
-DocType: Amazon MWS Settings,Market Place ID,市場ID
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +97,Head of Marketing and Sales,營銷和銷售主管
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +50,Income Tax,所得稅
-apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,以行業類型追蹤訊息。
-apps/erpnext/erpnext/utilities/user_progress.py +101,Go to Letterheads,去信頭
-apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +114,Property already added,已添加屬性
-DocType: Item Supplier,Item Supplier,產品供應商
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1389,Please enter Item Code to get batch no,請輸入產品編號，以取得批號
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +928,Please select a value for {0} quotation_to {1},請選擇一個值{0} quotation_to {1}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +435,No Items selected for transfer,沒有選擇轉移項目
-DocType: Company,Stock Settings,庫存設定
-apps/erpnext/erpnext/accounts/doctype/account/account.py +244,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company",合併是唯一可能的，如果以下屬性中均有記載相同。是集團，根型，公司
-DocType: Vehicle,Electric,電動
-DocType: Task,% Progress,％進展
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +130,Gain/Loss on Asset Disposal,在資產處置收益/損失
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +24,"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",下表中將只選擇狀態為“已批准”的學生申請人。
-DocType: Tax Withholding Category,Rates,價格
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +121,Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,科目{0}的科目號碼不可用。 <br>請正確設置您的會計科目表。
-DocType: Task,Depends on Tasks,取決於任務
-apps/erpnext/erpnext/config/selling.py +36,Manage Customer Group Tree.,管理客戶群組樹。
-DocType: Normal Test Items,Result Value,結果值
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22,New Cost Center Name,新的成本中心名稱
-DocType: Project,Task Completion,任務完成
-apps/erpnext/erpnext/templates/includes/product_page.js +31,Not in Stock,沒存貨
-DocType: Volunteer,Volunteer Skills,志願者技能
-DocType: Additional Salary,HR User,HR用戶
-DocType: Bank Guarantee,Reference Document Name,參考文件名稱
-DocType: Purchase Invoice,Taxes and Charges Deducted,稅收和費用扣除
-DocType: Support Settings,Issues,問題
-DocType: Loyalty Program,Loyalty Program Name,忠誠計劃名稱
-apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},狀態必須是一個{0}
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64,Reminder to update GSTIN Sent,提醒更新GSTIN發送
-DocType: Sales Invoice,Debit To,借方
-DocType: Restaurant Menu Item,Restaurant Menu Item,餐廳菜單項
-DocType: Delivery Note,Required only for sample item.,只對樣品項目所需。
-DocType: Stock Ledger Entry,Actual Qty After Transaction,交易後實際數量
-,Pending SO Items For Purchase Request,待處理的SO項目對於採購申請
-apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35,Student Admissions,學生入學
-apps/erpnext/erpnext/accounts/party.py +421,{0} {1} is disabled,{0} {1}被禁用
-DocType: Supplier,Billing Currency,結算貨幣
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +152,Extra Large,特大號
-DocType: Loan,Loan Application,申請貸款
-DocType: Crop,Scientific Name,科學名稱
-DocType: Healthcare Service Unit,Service Unit Type,服務單位類型
-DocType: Bank Account,Branch Code,分行代碼
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +97,Total Leaves,葉總
-DocType: Customer,"Reselect, if the chosen contact is edited after save",重新選擇，如果所選聯繫人在保存後被編輯
-DocType: Patient Encounter,In print,已出版
-,Profit and Loss Statement,損益表
-DocType: Bank Reconciliation Detail,Cheque Number,支票號碼
-apps/erpnext/erpnext/healthcare/utils.py +264,The item referenced by {0} - {1} is already invoiced,{0}  -  {1}引用的項目已開具發票
-,Sales Browser,銷售瀏覽器
-DocType: Journal Entry,Total Credit,貸方總額
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +586,Warning: Another {0} # {1} exists against stock entry {2},警告：另一個{0}＃{1}存在對庫存分錄{2}
-apps/erpnext/erpnext/utilities/user_progress_utils.py +66,Local,當地
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),貸款及墊款（資產）
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,債務人
-DocType: Bank Statement Settings,Bank Statement Settings,銀行對賬單設置
-DocType: Shopify Settings,Customer Settings,客戶設置
-DocType: Homepage Featured Product,Homepage Featured Product,首頁推薦產品
-apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js +12,View Orders,查看訂單
-DocType: Marketplace Settings,Marketplace URL (to hide and update label),市場URL（隱藏和更新標籤）
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +206,All Assessment Groups,所有評估組
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,新倉庫名稱
-DocType: Shopify Settings,App Type,應用類型
-apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py +401,Total {0} ({1}),總{0}（{1}）
-DocType: C-Form Invoice Detail,Territory,領土
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,Please mention no of visits required,請註明無需訪問
-DocType: Stock Settings,Default Valuation Method,預設的估值方法
-apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26,Fee,費用
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +59,Show Cumulative Amount,顯示累計金額
-apps/erpnext/erpnext/setup/doctype/company/company.js +174,Update in progress. It might take a while.,正在更新。它可能需要一段時間。
-DocType: Production Plan Item,Produced Qty,生產數量
-DocType: Vehicle Log,Fuel Qty,燃油數量
-DocType: Stock Entry,Target Warehouse Name,目標倉庫名稱
-DocType: Work Order Operation,Planned Start Time,計劃開始時間
-DocType: Course,Assessment,評定
-DocType: Payment Entry Reference,Allocated,分配
-apps/erpnext/erpnext/config/accounts.py +235,Close Balance Sheet and book Profit or Loss.,關閉資產負債表和賬面利潤或虧損。
-DocType: Student Applicant,Application Status,應用現狀
-DocType: Additional Salary,Salary Component Type,薪資組件類型
-DocType: Sensitivity Test Items,Sensitivity Test Items,靈敏度測試項目
-DocType: Project Update,Project Update,項目更新
-DocType: Fees,Fees,費用
-DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,指定的匯率將一種貨幣兌換成另一種
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +165,Quotation {0} is cancelled,{0}報價被取消
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +139,Total Outstanding Amount,未償還總額
-DocType: Sales Partner,Targets,目標
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js +40,Please register the SIREN number in the company information file,請在公司信息文件中註冊SIREN號碼
-DocType: Email Digest,Sales Orders to Bill,比爾的銷售訂單
-DocType: Price List,Price List Master,價格表主檔
-DocType: GST Account,CESS Account,CESS帳戶
-DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,所有的銷售交易，可以用來標記針對多個**銷售**的人，這樣你可以設置和監控目標。
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1184,Link to Material Request,鏈接到材料請求
-apps/erpnext/erpnext/templates/pages/help.html +35,Forum Activity,論壇活動
-,S.O. No.,SO號
-DocType: Bank Statement Transaction Settings Item,Bank Statement Transaction Settings Item,銀行對賬單交易設置項目
-apps/erpnext/erpnext/hr/utils.py +158,To date can not greater than employee's relieving date,迄今為止不能超過員工的免除日期
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +242,Please create Customer from Lead {0},請牽頭建立客戶{0}
-apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,Select Patient,選擇患者
-DocType: Price List,Applicable for Countries,適用於國家
-DocType: Supplier Scorecard Scoring Variable,Parameter Name,參數名稱
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +46,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,只留下地位的申請“已批准”和“拒絕”，就可以提交
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52,Student Group Name is mandatory in row {0},學生組名稱是強制性的行{0}
-DocType: Homepage,Products to be shown on website homepage,在網站首頁中顯示的產品
-apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,ERPNext是一個開源的基於Web的ERP系統，通過網路技術，向私人有限公司提供整合的工具，在一個小的組織管理大多數流程。有關Web註釋，或購買託管，想得到更多資訊，請連結
-DocType: Budget,Action if Accumulated Monthly Budget Exceeded on PO,採購訂單上累計每月預算超出時的操作
-DocType: Exchange Rate Revaluation,Exchange Rate Revaluation,匯率重估
-DocType: POS Profile,Ignore Pricing Rule,忽略定價規則
-DocType: Employee Education,Graduate,畢業生
-DocType: Leave Block List,Block Days,封鎖天數
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83,"Shipping Address does not have country, which is required for this Shipping Rule",送貨地址沒有國家，這是此送貨規則所必需的
-DocType: Journal Entry,Excise Entry,海關入境
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +69,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},警告：銷售訂單{0}已經存在針對客戶的採購訂單{1}
-DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.
+Material Request Type,材料需求類型
+Send Grant Review Email,發送格蘭特回顧郵件
+"LocalStorage is full, did not save",localStorage的是滿的，沒救
+Row {0}: UOM Conversion Factor is mandatory,行{0}：計量單位轉換係數是必需的
+Claim Date,索賠日期
+Room Capacity,房間容量
+Already record exists for the item {0},已有記錄存在項目{0}
+Ref,參考
+You will lose records of previously generated invoices. Are you sure you want to restart this subscription?,您將失去先前生成的發票記錄。您確定要重新啟用此訂閱嗎？
+Registration Fee,註冊費用
+Loyalty Program Collection,忠誠度計劃集
+Subcontracted Item,轉包項目
+Student {0} does not belong to group {1},學生{0}不屬於組{1}
+Voucher #,憑證＃
+Purchase Order Message,採購訂單的訊息
+Shipping Country,航運國家
+Hide Customer's Tax Id from Sales Transactions,從銷售交易隱藏客戶的稅號
+Upload HTML,上傳HTML,
+Relieving Date,解除日期
+Total Quantity,總數（量
+"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.",定價規則是由覆蓋價格表/定義折扣百分比，基於某些條件。
+Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,倉庫只能通過存貨分錄/送貨單/採購入庫單來改變
+Class / Percentage,類／百分比
+Shopify Settings,Shopify設置
+Market Place ID,市場ID,
+Head of Marketing and Sales,營銷和銷售主管
+Income Tax,所得稅
+Track Leads by Industry Type.,以行業類型追蹤訊息。
+Go to Letterheads,去信頭
+Property already added,已添加屬性
+Item Supplier,產品供應商
+Please enter Item Code to get batch no,請輸入產品編號，以取得批號
+Please select a value for {0} quotation_to {1},請選擇一個值{0} quotation_to {1}
+No Items selected for transfer,沒有選擇轉移項目
+Stock Settings,庫存設定
+"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company",合併是唯一可能的，如果以下屬性中均有記載相同。是集團，根型，公司
+Electric,電動
+% Progress,％進展
+Gain/Loss on Asset Disposal,在資產處置收益/損失
+"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",下表中將只選擇狀態為“已批准”的學生申請人。
+Rates,價格
+Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,科目{0}的科目號碼不可用。 <br>請正確設置您的會計科目表。
+Depends on Tasks,取決於任務
+Manage Customer Group Tree.,管理客戶群組樹。
+Result Value,結果值
+New Cost Center Name,新的成本中心名稱
+Task Completion,任務完成
+Not in Stock,沒存貨
+Volunteer Skills,志願者技能
+HR User,HR用戶
+Reference Document Name,參考文件名稱
+Taxes and Charges Deducted,稅收和費用扣除
+Issues,問題
+Loyalty Program Name,忠誠計劃名稱
+Status must be one of {0},狀態必須是一個{0}
+Reminder to update GSTIN Sent,提醒更新GSTIN發送
+Debit To,借方
+Restaurant Menu Item,餐廳菜單項
+Required only for sample item.,只對樣品項目所需。
+Actual Qty After Transaction,交易後實際數量
+Pending SO Items For Purchase Request,待處理的SO項目對於採購申請
+Student Admissions,學生入學
+{0} {1} is disabled,{0} {1}被禁用
+Billing Currency,結算貨幣
+Extra Large,特大號
+Loan Application,申請貸款
+Scientific Name,科學名稱
+Service Unit Type,服務單位類型
+Branch Code,分行代碼
+Total Leaves,葉總
+"Reselect, if the chosen contact is edited after save",重新選擇，如果所選聯繫人在保存後被編輯
+In print,已出版
+Profit and Loss Statement,損益表
+Cheque Number,支票號碼
+The item referenced by {0} - {1} is already invoiced,{0}  -  {1}引用的項目已開具發票
+Sales Browser,銷售瀏覽器
+Total Credit,貸方總額
+Warning: Another {0} # {1} exists against stock entry {2},警告：另一個{0}＃{1}存在對庫存分錄{2}
+Local,當地
+Loans and Advances (Assets),貸款及墊款（資產）
+Debtors,債務人
+Bank Statement Settings,銀行對賬單設置
+Customer Settings,客戶設置
+Homepage Featured Product,首頁推薦產品
+View Orders,查看訂單
+Marketplace URL (to hide and update label),市場URL（隱藏和更新標籤）
+All Assessment Groups,所有評估組
+New Warehouse Name,新倉庫名稱
+App Type,應用類型
+Total {0} ({1}),總{0}（{1}）
+Territory,領土
+Please mention no of visits required,請註明無需訪問
+Default Valuation Method,預設的估值方法
+Fee,費用
+Show Cumulative Amount,顯示累計金額
+Update in progress. It might take a while.,正在更新。它可能需要一段時間。
+Produced Qty,生產數量
+Fuel Qty,燃油數量
+Target Warehouse Name,目標倉庫名稱
+Planned Start Time,計劃開始時間
+Assessment,評定
+Allocated,分配
+Close Balance Sheet and book Profit or Loss.,關閉資產負債表和賬面利潤或虧損。
+Application Status,應用現狀
+Salary Component Type,薪資組件類型
+Sensitivity Test Items,靈敏度測試項目
+Project Update,項目更新
+Fees,費用
+Specify Exchange Rate to convert one currency into another,指定的匯率將一種貨幣兌換成另一種
+Quotation {0} is cancelled,{0}報價被取消
+Total Outstanding Amount,未償還總額
+Targets,目標
+Please register the SIREN number in the company information file,請在公司信息文件中註冊SIREN號碼
+Sales Orders to Bill,比爾的銷售訂單
+Price List Master,價格表主檔
+CESS Account,CESS帳戶
+All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,所有的銷售交易，可以用來標記針對多個**銷售**的人，這樣你可以設置和監控目標。
+Link to Material Request,鏈接到材料請求
+Forum Activity,論壇活動
+S.O. No.,SO號
+Bank Statement Transaction Settings Item,銀行對賬單交易設置項目
+To date can not greater than employee's relieving date,迄今為止不能超過員工的免除日期
+Please create Customer from Lead {0},請牽頭建立客戶{0}
+Select Patient,選擇患者
+Applicable for Countries,適用於國家
+Parameter Name,參數名稱
+Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,只留下地位的申請“已批准”和“拒絕”，就可以提交
+Student Group Name is mandatory in row {0},學生組名稱是強制性的行{0}
+Products to be shown on website homepage,在網站首頁中顯示的產品
+This is a root customer group and cannot be edited.,ERPNext是一個開源的基於Web的ERP系統，通過網路技術，向私人有限公司提供整合的工具，在一個小的組織管理大多數流程。有關Web註釋，或購買託管，想得到更多資訊，請連結
+Action if Accumulated Monthly Budget Exceeded on PO,採購訂單上累計每月預算超出時的操作
+Exchange Rate Revaluation,匯率重估
+Ignore Pricing Rule,忽略定價規則
+Graduate,畢業生
+Block Days,封鎖天數
+"Shipping Address does not have country, which is required for this Shipping Rule",送貨地址沒有國家，這是此送貨規則所必需的
+Excise Entry,海關入境
+Warning: Sales Order {0} already exists against Customer's Purchase Order {1},警告：銷售訂單{0}已經存在針對客戶的採購訂單{1}
+"Standard Terms and Conditions that can be added to Sales and Purchases.
 
 Examples:
 
@@ -3654,2895 +3654,2895 @@
  1。航運條款（如果適用）。
  1。的解決糾紛，賠償，法律責任等
  1的方式。地址和公司聯繫。"
-DocType: Issue,Issue Type,發行類型
-DocType: Attendance,Leave Type,休假類型
-DocType: Purchase Invoice,Supplier Invoice Details,供應商發票明細
-apps/erpnext/erpnext/controllers/stock_controller.py +237,Expense / Difference account ({0}) must be a 'Profit or Loss' account,費用/差異科目（{0}）必須是一個'收益或損失'的科目
-DocType: Project,Copied From,複製自
-DocType: Project,Copied From,複製自
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +265,Invoice already created for all billing hours,發票已在所有結算時間創建
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +177,Name error: {0},名稱錯誤：{0}
-DocType: Healthcare Service Unit Type,Item Details,產品詳細信息
-DocType: Cash Flow Mapping,Is Finance Cost,財務成本
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +19,Attendance for employee {0} is already marked,員工{0}的考勤已標記
-DocType: Packing Slip,If more than one package of the same type (for print),如果不止一個相同類型的包裹（用於列印）
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27,Please set default customer in Restaurant Settings,請在“餐廳設置”中設置默認客戶
-,Salary Register,薪酬註冊
-DocType: Warehouse,Parent Warehouse,家長倉庫
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +41,Chart,圖表
-DocType: Subscription,Net Total,總淨值
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +527,Default BOM not found for Item {0} and Project {1},項目{0}和項目{1}找不到默認BOM
-apps/erpnext/erpnext/config/non_profit.py +74,Define various loan types,定義不同的貸款類型
-DocType: Bank Statement Transaction Invoice Item,Outstanding Amount,未償還的金額
-apps/erpnext/erpnext/templates/generators/bom.html +71,Time(in mins),時間（分鐘）
-DocType: Project Task,Working,工作的
-DocType: Stock Ledger Entry,Stock Queue (FIFO),庫存序列（先進先出）
-apps/erpnext/erpnext/public/js/setup_wizard.js +128,Financial Year,財政年度
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46,{0} does not belong to Company {1},{0}不屬於公司{1}
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66,Could not solve criteria score function for {0}. Make sure the formula is valid.,無法解決{0}的標準分數函數。確保公式有效。
-apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +34,Repayment amount {} should be greater than monthly interest amount {},還款金額{}應大於每月的利息金額{}
-DocType: Healthcare Settings,Out Patient Settings,出患者設置
-DocType: Account,Round Off,四捨五入
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +305,Quantity must be positive,數量必須是正數
-DocType: Material Request Plan Item,Requested Qty,要求數量
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +97,The fields From Shareholder and To Shareholder cannot be blank,來自股東和股東的字段不能為空
-DocType: Cashier Closing,Cashier Closing,收銀員關閉
-DocType: Tax Rule,Use for Shopping Cart,使用的購物車
-apps/erpnext/erpnext/controllers/item_variant.py +101,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},值{0}的屬性{1}不在有效的項目列表中存在的屬性值項{2}
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +81,Select Serial Numbers,選擇序列號
-DocType: BOM Item,Scrap %,廢鋼％
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46,"Charges will be distributed proportionately based on item qty or amount, as per your selection",費用將被分配比例根據項目數量或金額，按您的選擇
-DocType: Travel Request,Require Full Funding,需要全額資助
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +110,Atleast one item should be entered with negative quantity in return document,ATLEAST一個項目應該負數量回報文檔中輸入
-apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations",操作{0}比任何可用的工作時間更長工作站{1}，分解成運行多個操作
-DocType: Membership,Membership Status,成員身份
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +121,No Remarks,暫無產品說明
-DocType: Asset,In Maintenance,在維護中
-DocType: Amazon MWS Settings,Click this button to pull your Sales Order data from Amazon MWS.,單擊此按鈕可從亞馬遜MWS中提取銷售訂單數據。
-DocType: Purchase Invoice,Overdue,過期的
-DocType: Account,Stock Received But Not Billed,庫存接收，但不付款
-apps/erpnext/erpnext/accounts/doctype/account/account.py +91,Root Account must be a group,Root 科目必須是群組科目
-DocType: Drug Prescription,Drug Prescription,藥物處方
-DocType: Loan,Repaid/Closed,償還/關閉
-DocType: Item,Total Projected Qty,預計總數量
-DocType: Monthly Distribution,Distribution Name,分配名稱
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +56,Include UOM,包括UOM
-apps/erpnext/erpnext/stock/stock_ledger.py +482,"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry",對於{1} {2}進行會計分錄所需的項目{0}，找不到估值。如果該項目在{1}中作為零估值率項目進行交易，請在{1}項目表中提及。否則，請在項目記錄中創建貨物的進貨庫存交易或提交估值費率，然後嘗試提交/取消此條目
-DocType: Course,Course Code,課程代碼
-apps/erpnext/erpnext/controllers/stock_controller.py +341,Quality Inspection required for Item {0},項目{0}需要品質檢驗
-DocType: POS Settings,Use POS in Offline Mode,在離線模式下使用POS
-DocType: Supplier Scorecard,Supplier Variables,供應商變量
-apps/erpnext/erpnext/accounts/page/pos/pos.js +77,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2},{0}是強制性的。可能沒有為{1}到{2}創建貨幣兌換記錄
-DocType: Quotation,Rate at which customer's currency is converted to company's base currency,客戶貨幣被換算成公司基礎貨幣的匯率
-DocType: Purchase Invoice Item,Net Rate (Company Currency),淨利率（公司貨幣）
-DocType: Salary Detail,Condition and Formula Help,條件和公式幫助
-apps/erpnext/erpnext/config/selling.py +105,Manage Territory Tree.,管理領地樹。
-DocType: Patient Service Unit,Patient Service Unit,病人服務單位
-DocType: Bank Statement Transaction Invoice Item,Sales Invoice,銷售發票
-DocType: Journal Entry Account,Party Balance,黨平衡
-DocType: Cash Flow Mapper,Section Subtotal,部分小計
-apps/erpnext/erpnext/accounts/page/pos/pos.js +500,Please select Apply Discount On,請選擇適用的折扣
-DocType: Stock Settings,Sample Retention Warehouse,樣品保留倉庫
-DocType: Company,Default Receivable Account,預設應收帳款
-DocType: Purchase Invoice,Deemed Export,被視為出口
-DocType: Stock Entry,Material Transfer for Manufacture,物料轉倉用於製造
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20,Discount Percentage can be applied either against a Price List or for all Price List.,折扣百分比可以應用於單一價目表或所有價目表。
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +432,Accounting Entry for Stock,存貨的會計分錄
-DocType: Lab Test,LabTest Approver,LabTest審批者
-apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +49,You have already assessed for the assessment criteria {}.,您已經評估了評估標準{}。
-DocType: Vehicle Service,Engine Oil,機油
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1084,Work Orders Created: {0},創建的工單：{0}
-DocType: Sales Invoice,Sales Team1,銷售團隊1
-apps/erpnext/erpnext/stock/doctype/item/item.py +578,Item {0} does not exist,項目{0}不存在
-DocType: Sales Invoice,Customer Address,客戶地址
-DocType: Loan,Loan Details,貸款詳情
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +62,Failed to setup post company fixtures,未能設置公司固定裝置
-DocType: Company,Default Inventory Account,默認庫存科目
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +193,The folio numbers are not matching,作品集編號不匹配
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +304,Payment Request for {0},付款申請{0}
-DocType: Item Barcode,Barcode Type,條碼類型
-DocType: Antibiotic,Antibiotic Name,抗生素名稱
-apps/erpnext/erpnext/config/buying.py +43,Supplier Group master.,供應商組主人。
-DocType: Healthcare Service Unit,Occupancy Status,佔用狀況
-DocType: Purchase Invoice,Apply Additional Discount On,收取額外折扣
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +66,Select Type...,選擇類型...
-DocType: Account,Root Type,root類型
-DocType: Item,FIFO,FIFO
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +558,Close the POS,關閉POS
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +139,Row # {0}: Cannot return more than {1} for Item {2},行＃{0}：無法返回超過{1}項{2}
-DocType: Item Group,Show this slideshow at the top of the page,這顯示在幻燈片頁面頂部
-DocType: BOM,Item UOM,項目計量單位
-DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),稅額後，優惠金額（公司貨幣）
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +256,Target warehouse is mandatory for row {0},目標倉庫是強制性的行{0}
-DocType: Cheque Print Template,Primary Settings,主要設置
-DocType: Purchase Invoice,Select Supplier Address,選擇供應商地址
-apps/erpnext/erpnext/public/js/event.js +27,Add Employees,添加員工
-DocType: Purchase Invoice Item,Quality Inspection,品質檢驗
-DocType: Company,Standard Template,標準模板
-DocType: Training Event,Theory,理論
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +1103,Warning: Material Requested Qty is less than Minimum Order Qty,警告：物料需求的數量低於最少訂購量
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +212,Account {0} is frozen,帳戶{0}被凍結
-DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,法人/子公司與帳戶的獨立走勢屬於該組織。
-DocType: Payment Request,Mute Email,靜音電子郵件
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29,"Food, Beverage & Tobacco",食品、飲料＆煙草
-DocType: Account,Account Number,帳號
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +794,Can only make payment against unbilled {0},只能使支付對未付款的{0}
-apps/erpnext/erpnext/controllers/selling_controller.py +114,Commission rate cannot be greater than 100,佣金比率不能大於100
-DocType: Sales Invoice,Allocate Advances Automatically (FIFO),自動分配進度（FIFO）
-DocType: Volunteer,Volunteer,志願者
-DocType: Buying Settings,Subcontract,轉包
-apps/erpnext/erpnext/public/js/utils/party.js +167,Please enter {0} first,請輸入{0}第一
-apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +104,No replies from,從沒有回复
-DocType: Work Order Operation,Actual End Time,實際結束時間
-DocType: Item,Manufacturer Part Number,製造商零件編號
-DocType: Taxable Salary Slab,Taxable Salary Slab,應納稅薪金平台
-DocType: Work Order Operation,Estimated Time and Cost,估計時間和成本
-DocType: Bin,Bin,箱子
-DocType: Crop,Crop Name,作物名稱
-apps/erpnext/erpnext/hub_node/api.py +54,Only users with {0} role can register on Marketplace,只有{0}角色的用戶才能在Marketplace上註冊
-DocType: SMS Log,No of Sent SMS,沒有發送短信
-apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py +8,Appointments and Encounters,約會和遭遇
-DocType: Antibiotic,Healthcare Administrator,醫療管理員
-apps/erpnext/erpnext/utilities/user_progress.py +47,Set a Target,設定目標
-DocType: Dosage Strength,Dosage Strength,劑量強度
-DocType: Healthcare Practitioner,Inpatient Visit Charge,住院訪問費用
-DocType: Account,Expense Account,費用科目
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,軟件
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155,Colour,顏色
-DocType: Assessment Plan Criteria,Assessment Plan Criteria,評估計劃標準
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +123,Expiry date is mandatory for selected item,有效期限對所選項目是強制性的
-DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,防止採購訂單
-DocType: Patient Appointment,Scheduled,預定
-apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,詢價。
-apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle",請選擇項，其中“正股項”是“否”和“是銷售物品”是“是”，沒有其他產品捆綁
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148,Select Customer,選擇客戶
-DocType: Student Log,Academic,學術的
-DocType: Patient,Personal and Social History,個人和社會史
-apps/erpnext/erpnext/education/doctype/guardian/guardian.py +51,User {0} created,用戶{0}已創建
-DocType: Fee Schedule,Fee Breakup for each student,每名學生的費用分手
-apps/erpnext/erpnext/controllers/accounts_controller.py +617,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),總的超前（{0}）對二階{1}不能大於總計（{2}）
-DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,選擇按月分佈橫跨幾個月不均勻分佈的目標。
-apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js +88,Change Code,更改代碼
-DocType: Purchase Invoice Item,Valuation Rate,估值率
-DocType: Vehicle,Diesel,柴油機
-apps/erpnext/erpnext/stock/get_item_details.py +546,Price List Currency not selected,尚未選擇價格表之貨幣
-DocType: Purchase Invoice,Availed ITC Cess,採用ITC Cess
-,Student Monthly Attendance Sheet,學生每月考勤表
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96,Shipping rule only applicable for Selling,運費規則僅適用於銷售
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +219,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,折舊行{0}：下一個折舊日期不能在購買日期之前
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,專案開始日期
-DocType: Rename Tool,Rename Log,重命名日誌
-apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,學生組或課程表是強制性的
-apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,學生組或課程表是強制性的
-DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,維護發票時間和工作時間的時間表相同
-DocType: Maintenance Visit Purpose,Against Document No,對文件編號
-DocType: BOM,Scrap,廢料
-apps/erpnext/erpnext/utilities/user_progress.py +217,Go to Instructors,去教練
-apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,管理銷售合作夥伴。
-DocType: Quality Inspection,Inspection Type,檢驗類型
-DocType: Fee Validity,Visited yet,已訪問
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +135,Warehouses with existing transaction can not be converted to group.,與現有的交易倉庫不能轉換為組。
-DocType: Assessment Result Tool,Result HTML,結果HTML
-DocType: Selling Settings,How often should project and company be updated based on Sales Transactions.,項目和公司應根據銷售交易多久更新一次。
-apps/erpnext/erpnext/utilities/activation.py +117,Add Students,新增學生
-apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js +18,Please select {0},請選擇{0}
-DocType: C-Form,C-Form No,C-表格編號
-DocType: BOM,Exploded_items,Exploded_items
-DocType: Delivery Stop,Distance,距離
-apps/erpnext/erpnext/utilities/user_progress.py +139,List your products or services that you buy or sell.,列出您所購買或出售的產品或服務。
-DocType: Water Analysis,Storage Temperature,儲存溫度
-DocType: Employee Attendance Tool,Unmarked Attendance,無標記考勤
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +256,Creating Payment Entries......,創建支付條目......
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100,Researcher,研究員
-DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,計劃註冊學生工具
-apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16,Start date should be less than end date for task {0},開始日期應該小於任務{0}的結束日期
-,Consolidated Financial Statement,合併財務報表
-apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,姓名或電子郵件是強制性
-DocType: Instructor,Instructor Log,講師日誌
-DocType: Clinical Procedure,Clinical Procedure,臨床程序
-DocType: Shopify Settings,Delivery Note Series,送貨單系列
-DocType: Purchase Order Item,Returned Qty,返回的數量
-DocType: Student,Exit,出口
-apps/erpnext/erpnext/accounts/doctype/account/account.py +163,Root Type is mandatory,root類型是強制性的
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +30,Failed to install presets,無法安裝預設
-DocType: Healthcare Service Unit Type,UOM Conversion in Hours,UOM按小時轉換
-DocType: Contract,Signee Details,簽名詳情
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +44,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.",{0}目前擁有{1}供應商記分卡，並且謹慎地向該供應商發出詢價。
-DocType: Certified Consultant,Non Profit Manager,非營利經理
-DocType: BOM,Total Cost(Company Currency),總成本（公司貨幣）
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +398,Serial No {0} created,序列號{0}創建
-DocType: Homepage,Company Description for website homepage,公司介紹了網站的首頁
-DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes",為方便客戶，這些代碼可以在列印格式，如發票和送貨單使用
-apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18,Suplier Name,Suplier名稱
-apps/erpnext/erpnext/accounts/report/financial_statements.py +177,Could not retrieve information for {0}.,無法檢索{0}的信息。
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +141,Opening Entry Journal,開幕詞報
-DocType: Contract,Fulfilment Terms,履行條款
-DocType: Sales Invoice,Time Sheet List,時間表列表
-DocType: Employee,You can enter any date manually,您可以手動輸入任何日期
-DocType: Healthcare Settings,Result Printed,結果打印
-DocType: Asset Category Account,Depreciation Expense Account,折舊費用科目
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191,Probationary Period,試用期
-DocType: Purchase Taxes and Charges Template,Is Inter State,是國際
-apps/erpnext/erpnext/config/hr.py +269,Shift Management,班次管理
-DocType: Customer Group,Only leaf nodes are allowed in transaction,只有葉節點中允許交易
-DocType: Project,Total Costing Amount (via Timesheets),總成本金額（通過時間表）
-DocType: Department,Expense Approver,費用審批
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +168,Row {0}: Advance against Customer must be credit,行{0}：提前對客戶必須是信用
-DocType: Project,Hourly,每小時
-apps/erpnext/erpnext/accounts/doctype/account/account.js +88,Non-Group to Group,非集團集團
-DocType: Employee,ERPNext User,ERPNext用戶
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},在{0}行中必須使用批處理
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},在{0}行中必須使用批處理
-DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,採購入庫項目供應商
-DocType: Amazon MWS Settings,Enable Scheduled Synch,啟用預定同步
-apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,以日期時間
-apps/erpnext/erpnext/config/selling.py +308,Logs for maintaining sms delivery status,日誌維護短信發送狀態
-DocType: Accounts Settings,Make Payment via Journal Entry,通過日記帳分錄進行付款
-DocType: Clinical Procedure Template,Clinical Procedure Template,臨床步驟模板
-DocType: Item,Inspection Required before Delivery,分娩前檢查所需
-DocType: Item,Inspection Required before Purchase,購買前檢查所需
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,待活動
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js +41,Create Lab Test,創建實驗室測試
-DocType: Patient Appointment,Reminded,提醒
-apps/erpnext/erpnext/public/js/setup_wizard.js +126,View Chart of Accounts,查看會計科目表
-DocType: Chapter Member,Chapter Member,章會員
-DocType: Material Request Plan Item,Minimum Order Quantity,最小起訂量
-apps/erpnext/erpnext/public/js/setup_wizard.js +106,Your Organization,你的組織
-apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +84,"Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}",跳過以下員工的休假分配，因為已經存在針對他們的休假分配記錄。 {0}
-DocType: Fee Component,Fees Category,費用類別
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +151,Please enter relieving date.,請輸入解除日期。
-apps/erpnext/erpnext/controllers/trends.py +149,Amt,AMT
-DocType: Travel Request,"Details of Sponsor (Name, Location)",贊助商詳情（名稱，地點）
-DocType: Supplier Scorecard,Notify Employee,通知員工
-DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,輸入活動的名稱，如果查詢來源是運動
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38,Newspaper Publishers,報紙出版商
-apps/erpnext/erpnext/hr/utils.py +154,Future dates not allowed,未來的日期不允許
-apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30,Select Fiscal Year,選擇財政年度
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +119,Expected Delivery Date should be after Sales Order Date,預計交貨日期應在銷售訂單日期之後
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,重新排序級別
-DocType: Company,Chart Of Accounts Template,會計科目模板
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +80,Update stock must be enable for the purchase invoice {0},必須為購買發票{0}啟用更新庫存
-apps/erpnext/erpnext/stock/get_item_details.py +405,Item Price updated for {0} in Price List {1},項目價格更新{0}價格表{1}
-DocType: Salary Structure,Salary breakup based on Earning and Deduction.,工資分手基於盈利和演繹。
-apps/erpnext/erpnext/accounts/doctype/account/account.py +135,Account with child nodes cannot be converted to ledger,有子節點的帳不能轉換到總帳
-DocType: Purchase Invoice Item,Accepted Warehouse,收料倉庫
-DocType: Bank Reconciliation Detail,Posting Date,發布日期
-apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +30,One customer can be part of only single Loyalty Program.,一個客戶只能參與一個忠誠度計劃。
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203,Mark Half Day,馬克半天
-DocType: Sales Invoice,Sales Team,銷售團隊
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +88,Duplicate entry,重複的條目
-apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py +19,Enter the name of the Beneficiary before submittting.,在提交之前輸入受益人的姓名。
-DocType: Program Enrollment Tool,Get Students,讓學生
-DocType: Serial No,Under Warranty,在保修期
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +530,[Error],[錯誤]
-DocType: Sales Order,In Words will be visible once you save the Sales Order.,銷售訂單一被儲存，就會顯示出來。
-,Employee Birthday,員工生日
-apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14,Please select Completion Date for Completed Repair,請選擇完成修復的完成日期
-DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,學生考勤批處理工具
-apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,計劃的高級
-DocType: Company,Date of Establishment,成立時間
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55,Venture Capital,創業投資
-apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,這個“學年”一個學期{0}和“術語名稱”{1}已經存在。請修改這些條目，然後再試一次。
-DocType: UOM,Must be Whole Number,必須是整數
-DocType: Leave Control Panel,New Leaves Allocated (In Days),新的排假（天）
-DocType: Purchase Invoice,Invoice Copy,發票副本
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,序列號{0}不存在
-DocType: Sales Invoice Item,Customer Warehouse (Optional),客戶倉庫（可選）
-DocType: Blanket Order Item,Blanket Order Item,一攬子訂單項目
-DocType: Payment Reconciliation Invoice,Invoice Number,發票號碼
-DocType: Shopping Cart Settings,Orders,訂單
-DocType: Travel Request,Event Details,活動詳情
-DocType: Department,Leave Approver,休假審批人
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +316,Please select a batch,請選擇一個批次
-apps/erpnext/erpnext/config/hr.py +145,Travel and Expense Claim,旅行和費用索賠
-DocType: Sales Invoice,Redemption Cost Center,贖回成本中心
-DocType: QuickBooks Migrator,Scope,範圍
-DocType: Assessment Group,Assessment Group Name,評估小組名稱
-DocType: Manufacturing Settings,Material Transferred for Manufacture,轉移至製造的物料
-apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +60,Add to Details,添加到詳細信息
-DocType: Travel Itinerary,Taxi,出租車
-DocType: Shopify Settings,Last Sync Datetime,上次同步日期時間
-DocType: Landed Cost Item,Receipt Document Type,收據憑證類型
-DocType: Daily Work Summary Settings,Select Companies,選擇公司
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +225,Proposal/Price Quote,提案/報價
-DocType: Antibiotic,Healthcare,衛生保健
-DocType: Target Detail,Target Detail,目標詳細資訊
-apps/erpnext/erpnext/stock/doctype/item/item.js +67,Single Variant,單一變種
-apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +51,All Jobs,所有職位
-DocType: Sales Order,% of materials billed against this Sales Order,針對這張銷售訂單的已開立帳單的百分比(%)
-DocType: Program Enrollment,Mode of Transportation,運輸方式
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +65,Period Closing Entry,期末進入
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +72,Select Department...,選擇部門...
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +40,Cost Center with existing transactions can not be converted to group,與現有的交易成本中心，不能轉化為組
-DocType: QuickBooks Migrator,Authorization URL,授權URL
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +376,Amount {0} {1} {2} {3},金額{0} {1} {2} {3}
-DocType: Account,Depreciation,折舊
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +103,The number of shares and the share numbers are inconsistent,股份數量和庫存數量不一致
-apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +50,Supplier(s),供應商（S）
-DocType: Employee Attendance Tool,Employee Attendance Tool,員工考勤工具
-DocType: Guardian Student,Guardian Student,學生監護人
-DocType: Supplier,Credit Limit,信用額度
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +77,Avg. Selling Price List Rate,平均。出售價目表率
-DocType: Additional Salary,Salary Component,薪金部分
-apps/erpnext/erpnext/accounts/utils.py +519,Payment Entries {0} are un-linked,付款項{0}是聯合國聯
-DocType: GL Entry,Voucher No,憑證編號
-,Lead Owner Efficiency,主導效率
-,Lead Owner Efficiency,主導效率
-apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +65,"You can claim only an amount of {0}, the rest amount {1} should be in the application \
+Issue Type,發行類型
+Leave Type,休假類型
+Supplier Invoice Details,供應商發票明細
+Expense / Difference account ({0}) must be a 'Profit or Loss' account,費用/差異科目（{0}）必須是一個'收益或損失'的科目
+Copied From,複製自
+Copied From,複製自
+Invoice already created for all billing hours,發票已在所有結算時間創建
+Name error: {0},名稱錯誤：{0}
+Item Details,產品詳細信息
+Is Finance Cost,財務成本
+Attendance for employee {0} is already marked,員工{0}的考勤已標記
+If more than one package of the same type (for print),如果不止一個相同類型的包裹（用於列印）
+Please set default customer in Restaurant Settings,請在“餐廳設置”中設置默認客戶
+Salary Register,薪酬註冊
+Parent Warehouse,家長倉庫
+Chart,圖表
+Net Total,總淨值
+Default BOM not found for Item {0} and Project {1},項目{0}和項目{1}找不到默認BOM,
+Define various loan types,定義不同的貸款類型
+Outstanding Amount,未償還的金額
+Time(in mins),時間（分鐘）
+Working,工作的
+Stock Queue (FIFO),庫存序列（先進先出）
+Financial Year,財政年度
+{0} does not belong to Company {1},{0}不屬於公司{1}
+Could not solve criteria score function for {0}. Make sure the formula is valid.,無法解決{0}的標準分數函數。確保公式有效。
+Repayment amount {} should be greater than monthly interest amount {},還款金額{}應大於每月的利息金額{}
+Out Patient Settings,出患者設置
+Round Off,四捨五入
+Quantity must be positive,數量必須是正數
+Requested Qty,要求數量
+The fields From Shareholder and To Shareholder cannot be blank,來自股東和股東的字段不能為空
+Cashier Closing,收銀員關閉
+Use for Shopping Cart,使用的購物車
+Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},值{0}的屬性{1}不在有效的項目列表中存在的屬性值項{2}
+Select Serial Numbers,選擇序列號
+Scrap %,廢鋼％
+"Charges will be distributed proportionately based on item qty or amount, as per your selection",費用將被分配比例根據項目數量或金額，按您的選擇
+Require Full Funding,需要全額資助
+Atleast one item should be entered with negative quantity in return document,ATLEAST一個項目應該負數量回報文檔中輸入
+"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations",操作{0}比任何可用的工作時間更長工作站{1}，分解成運行多個操作
+Membership Status,成員身份
+No Remarks,暫無產品說明
+In Maintenance,在維護中
+Click this button to pull your Sales Order data from Amazon MWS.,單擊此按鈕可從亞馬遜MWS中提取銷售訂單數據。
+Overdue,過期的
+Stock Received But Not Billed,庫存接收，但不付款
+Root Account must be a group,Root 科目必須是群組科目
+Drug Prescription,藥物處方
+Repaid/Closed,償還/關閉
+Total Projected Qty,預計總數量
+Distribution Name,分配名稱
+Include UOM,包括UOM,
+"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry",對於{1} {2}進行會計分錄所需的項目{0}，找不到估值。如果該項目在{1}中作為零估值率項目進行交易，請在{1}項目表中提及。否則，請在項目記錄中創建貨物的進貨庫存交易或提交估值費率，然後嘗試提交/取消此條目
+Course Code,課程代碼
+Quality Inspection required for Item {0},項目{0}需要品質檢驗
+Use POS in Offline Mode,在離線模式下使用POS,
+Supplier Variables,供應商變量
+{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2},{0}是強制性的。可能沒有為{1}到{2}創建貨幣兌換記錄
+Rate at which customer's currency is converted to company's base currency,客戶貨幣被換算成公司基礎貨幣的匯率
+Net Rate (Company Currency),淨利率（公司貨幣）
+Condition and Formula Help,條件和公式幫助
+Manage Territory Tree.,管理領地樹。
+Patient Service Unit,病人服務單位
+Sales Invoice,銷售發票
+Party Balance,黨平衡
+Section Subtotal,部分小計
+Please select Apply Discount On,請選擇適用的折扣
+Sample Retention Warehouse,樣品保留倉庫
+Default Receivable Account,預設應收帳款
+Deemed Export,被視為出口
+Material Transfer for Manufacture,物料轉倉用於製造
+Discount Percentage can be applied either against a Price List or for all Price List.,折扣百分比可以應用於單一價目表或所有價目表。
+Accounting Entry for Stock,存貨的會計分錄
+LabTest Approver,LabTest審批者
+You have already assessed for the assessment criteria {}.,您已經評估了評估標準{}。
+Engine Oil,機油
+Work Orders Created: {0},創建的工單：{0}
+Sales Team1,銷售團隊1,
+Item {0} does not exist,項目{0}不存在
+Customer Address,客戶地址
+Loan Details,貸款詳情
+Failed to setup post company fixtures,未能設置公司固定裝置
+Default Inventory Account,默認庫存科目
+The folio numbers are not matching,作品集編號不匹配
+Payment Request for {0},付款申請{0}
+Barcode Type,條碼類型
+Antibiotic Name,抗生素名稱
+Supplier Group master.,供應商組主人。
+Occupancy Status,佔用狀況
+Apply Additional Discount On,收取額外折扣
+Select Type...,選擇類型...
+Root Type,root類型
+FIFO,FIFO,
+Close the POS,關閉POS,
+Row # {0}: Cannot return more than {1} for Item {2},行＃{0}：無法返回超過{1}項{2}
+Show this slideshow at the top of the page,這顯示在幻燈片頁面頂部
+Item UOM,項目計量單位
+Tax Amount After Discount Amount (Company Currency),稅額後，優惠金額（公司貨幣）
+Target warehouse is mandatory for row {0},目標倉庫是強制性的行{0}
+Primary Settings,主要設置
+Select Supplier Address,選擇供應商地址
+Add Employees,添加員工
+Quality Inspection,品質檢驗
+Standard Template,標準模板
+Theory,理論
+Warning: Material Requested Qty is less than Minimum Order Qty,警告：物料需求的數量低於最少訂購量
+Account {0} is frozen,帳戶{0}被凍結
+Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,法人/子公司與帳戶的獨立走勢屬於該組織。
+Mute Email,靜音電子郵件
+"Food, Beverage & Tobacco",食品、飲料＆煙草
+Account Number,帳號
+Can only make payment against unbilled {0},只能使支付對未付款的{0}
+Commission rate cannot be greater than 100,佣金比率不能大於100,
+Allocate Advances Automatically (FIFO),自動分配進度（FIFO）
+Volunteer,志願者
+Subcontract,轉包
+Please enter {0} first,請輸入{0}第一
+No replies from,從沒有回复
+Actual End Time,實際結束時間
+Manufacturer Part Number,製造商零件編號
+Taxable Salary Slab,應納稅薪金平台
+Estimated Time and Cost,估計時間和成本
+Bin,箱子
+Crop Name,作物名稱
+Only users with {0} role can register on Marketplace,只有{0}角色的用戶才能在Marketplace上註冊
+No of Sent SMS,沒有發送短信
+Appointments and Encounters,約會和遭遇
+Healthcare Administrator,醫療管理員
+Set a Target,設定目標
+Dosage Strength,劑量強度
+Inpatient Visit Charge,住院訪問費用
+Expense Account,費用科目
+Software,軟件
+Colour,顏色
+Assessment Plan Criteria,評估計劃標準
+Expiry date is mandatory for selected item,有效期限對所選項目是強制性的
+Prevent Purchase Orders,防止採購訂單
+Scheduled,預定
+Request for quotation.,詢價。
+"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle",請選擇項，其中“正股項”是“否”和“是銷售物品”是“是”，沒有其他產品捆綁
+Select Customer,選擇客戶
+Academic,學術的
+Personal and Social History,個人和社會史
+User {0} created,用戶{0}已創建
+Fee Breakup for each student,每名學生的費用分手
+Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),總的超前（{0}）對二階{1}不能大於總計（{2}）
+Select Monthly Distribution to unevenly distribute targets across months.,選擇按月分佈橫跨幾個月不均勻分佈的目標。
+Change Code,更改代碼
+Valuation Rate,估值率
+Diesel,柴油機
+Price List Currency not selected,尚未選擇價格表之貨幣
+Availed ITC Cess,採用ITC Cess,
+Student Monthly Attendance Sheet,學生每月考勤表
+Shipping rule only applicable for Selling,運費規則僅適用於銷售
+Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,折舊行{0}：下一個折舊日期不能在購買日期之前
+Project Start Date,專案開始日期
+Rename Log,重命名日誌
+Student Group or Course Schedule is mandatory,學生組或課程表是強制性的
+Student Group or Course Schedule is mandatory,學生組或課程表是強制性的
+Maintain Billing Hours and Working Hours Same on Timesheet,維護發票時間和工作時間的時間表相同
+Against Document No,對文件編號
+Scrap,廢料
+Go to Instructors,去教練
+Manage Sales Partners.,管理銷售合作夥伴。
+Inspection Type,檢驗類型
+Visited yet,已訪問
+Warehouses with existing transaction can not be converted to group.,與現有的交易倉庫不能轉換為組。
+Result HTML,結果HTML,
+How often should project and company be updated based on Sales Transactions.,項目和公司應根據銷售交易多久更新一次。
+Add Students,新增學生
+Please select {0},請選擇{0}
+C-Form No,C-表格編號
+Exploded_items,Exploded_items,
+Distance,距離
+List your products or services that you buy or sell.,列出您所購買或出售的產品或服務。
+Storage Temperature,儲存溫度
+Unmarked Attendance,無標記考勤
+Creating Payment Entries......,創建支付條目......
+Researcher,研究員
+Program Enrollment Tool Student,計劃註冊學生工具
+Start date should be less than end date for task {0},開始日期應該小於任務{0}的結束日期
+Consolidated Financial Statement,合併財務報表
+Name or Email is mandatory,姓名或電子郵件是強制性
+Instructor Log,講師日誌
+Clinical Procedure,臨床程序
+Delivery Note Series,送貨單系列
+Returned Qty,返回的數量
+Exit,出口
+Root Type is mandatory,root類型是強制性的
+Failed to install presets,無法安裝預設
+UOM Conversion in Hours,UOM按小時轉換
+Signee Details,簽名詳情
+"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.",{0}目前擁有{1}供應商記分卡，並且謹慎地向該供應商發出詢價。
+Non Profit Manager,非營利經理
+Total Cost(Company Currency),總成本（公司貨幣）
+Serial No {0} created,序列號{0}創建
+Company Description for website homepage,公司介紹了網站的首頁
+"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes",為方便客戶，這些代碼可以在列印格式，如發票和送貨單使用
+Suplier Name,Suplier名稱
+Could not retrieve information for {0}.,無法檢索{0}的信息。
+Opening Entry Journal,開幕詞報
+Fulfilment Terms,履行條款
+Time Sheet List,時間表列表
+You can enter any date manually,您可以手動輸入任何日期
+Result Printed,結果打印
+Depreciation Expense Account,折舊費用科目
+Probationary Period,試用期
+Is Inter State,是國際
+Shift Management,班次管理
+Only leaf nodes are allowed in transaction,只有葉節點中允許交易
+Total Costing Amount (via Timesheets),總成本金額（通過時間表）
+Expense Approver,費用審批
+Row {0}: Advance against Customer must be credit,行{0}：提前對客戶必須是信用
+Hourly,每小時
+Non-Group to Group,非集團集團
+ERPNext User,ERPNext用戶
+Batch is mandatory in row {0},在{0}行中必須使用批處理
+Batch is mandatory in row {0},在{0}行中必須使用批處理
+Purchase Receipt Item Supplied,採購入庫項目供應商
+Enable Scheduled Synch,啟用預定同步
+To Datetime,以日期時間
+Logs for maintaining sms delivery status,日誌維護短信發送狀態
+Make Payment via Journal Entry,通過日記帳分錄進行付款
+Clinical Procedure Template,臨床步驟模板
+Inspection Required before Delivery,分娩前檢查所需
+Inspection Required before Purchase,購買前檢查所需
+Pending Activities,待活動
+Create Lab Test,創建實驗室測試
+Reminded,提醒
+View Chart of Accounts,查看會計科目表
+Chapter Member,章會員
+Minimum Order Quantity,最小起訂量
+Your Organization,你的組織
+"Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}",跳過以下員工的休假分配，因為已經存在針對他們的休假分配記錄。 {0}
+Fees Category,費用類別
+Please enter relieving date.,請輸入解除日期。
+Amt,AMT,
+"Details of Sponsor (Name, Location)",贊助商詳情（名稱，地點）
+Notify Employee,通知員工
+Enter name of campaign if source of enquiry is campaign,輸入活動的名稱，如果查詢來源是運動
+Newspaper Publishers,報紙出版商
+Future dates not allowed,未來的日期不允許
+Select Fiscal Year,選擇財政年度
+Expected Delivery Date should be after Sales Order Date,預計交貨日期應在銷售訂單日期之後
+Reorder Level,重新排序級別
+Chart Of Accounts Template,會計科目模板
+Update stock must be enable for the purchase invoice {0},必須為購買發票{0}啟用更新庫存
+Item Price updated for {0} in Price List {1},項目價格更新{0}價格表{1}
+Salary breakup based on Earning and Deduction.,工資分手基於盈利和演繹。
+Account with child nodes cannot be converted to ledger,有子節點的帳不能轉換到總帳
+Accepted Warehouse,收料倉庫
+Posting Date,發布日期
+One customer can be part of only single Loyalty Program.,一個客戶只能參與一個忠誠度計劃。
+Mark Half Day,馬克半天
+Sales Team,銷售團隊
+Duplicate entry,重複的條目
+Enter the name of the Beneficiary before submittting.,在提交之前輸入受益人的姓名。
+Get Students,讓學生
+Under Warranty,在保修期
+[Error],[錯誤]
+In Words will be visible once you save the Sales Order.,銷售訂單一被儲存，就會顯示出來。
+Employee Birthday,員工生日
+Please select Completion Date for Completed Repair,請選擇完成修復的完成日期
+Student Batch Attendance Tool,學生考勤批處理工具
+Scheduled Upto,計劃的高級
+Date of Establishment,成立時間
+Venture Capital,創業投資
+An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,這個“學年”一個學期{0}和“術語名稱”{1}已經存在。請修改這些條目，然後再試一次。
+Must be Whole Number,必須是整數
+New Leaves Allocated (In Days),新的排假（天）
+Invoice Copy,發票副本
+Serial No {0} does not exist,序列號{0}不存在
+Customer Warehouse (Optional),客戶倉庫（可選）
+Blanket Order Item,一攬子訂單項目
+Invoice Number,發票號碼
+Orders,訂單
+Event Details,活動詳情
+Leave Approver,休假審批人
+Please select a batch,請選擇一個批次
+Travel and Expense Claim,旅行和費用索賠
+Redemption Cost Center,贖回成本中心
+Scope,範圍
+Assessment Group Name,評估小組名稱
+Material Transferred for Manufacture,轉移至製造的物料
+Add to Details,添加到詳細信息
+Taxi,出租車
+Last Sync Datetime,上次同步日期時間
+Receipt Document Type,收據憑證類型
+Select Companies,選擇公司
+Proposal/Price Quote,提案/報價
+Healthcare,衛生保健
+Target Detail,目標詳細資訊
+Single Variant,單一變種
+All Jobs,所有職位
+% of materials billed against this Sales Order,針對這張銷售訂單的已開立帳單的百分比(%)
+Mode of Transportation,運輸方式
+Period Closing Entry,期末進入
+Select Department...,選擇部門...
+Cost Center with existing transactions can not be converted to group,與現有的交易成本中心，不能轉化為組
+Authorization URL,授權URL,
+Amount {0} {1} {2} {3},金額{0} {1} {2} {3}
+Depreciation,折舊
+The number of shares and the share numbers are inconsistent,股份數量和庫存數量不一致
+Supplier(s),供應商（S）
+Employee Attendance Tool,員工考勤工具
+Guardian Student,學生監護人
+Credit Limit,信用額度
+Avg. Selling Price List Rate,平均。出售價目表率
+Salary Component,薪金部分
+Payment Entries {0} are un-linked,付款項{0}是聯合國聯
+Voucher No,憑證編號
+Lead Owner Efficiency,主導效率
+Lead Owner Efficiency,主導效率
+"You can claim only an amount of {0}, the rest amount {1} should be in the application \
 				as pro-rata component",您只能聲明一定數量的{0}，剩餘數量{1}應該在應用程序中作為按比例分量
-DocType: Amazon MWS Settings,Customer Type,客戶類型
-DocType: Compensatory Leave Request,Leave Allocation,排假
-DocType: Payment Request,Recipient Message And Payment Details,收件人郵件和付款細節
-DocType: Support Search Source,Source DocType,源DocType
-apps/erpnext/erpnext/templates/pages/help.html +60,Open a new ticket,打開一張新票
-DocType: Training Event,Trainer Email,教練電子郵件
-DocType: Driver,Transporter,運輸車
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550,Material Requests {0} created,{0}物料需求已建立
-DocType: Restaurant Reservation,No of People,沒有人
-apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,模板條款或合同。
-DocType: Bank Account,Address and Contact,地址和聯絡方式
-DocType: Cheque Print Template,Is Account Payable,為應付帳款
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +306,Stock cannot be updated against Purchase Receipt {0},庫存不能對外購入庫單進行更新{0}
-DocType: Support Settings,Auto close Issue after 7 days,7天之後自動關閉問題
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +85,"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}",假，不是之前分配{0}，因為休假餘額已經結轉轉發在未來的假期分配記錄{1}
-apps/erpnext/erpnext/accounts/party.py +350,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),註：由於/參考日期由{0}天超過了允許客戶的信用天數（S）
-apps/erpnext/erpnext/education/doctype/program/program.js +8,Student Applicant,學生申請
-DocType: Hub Tracked Item,Hub Tracked Item,Hub跟踪物品
-DocType: Asset Category Account,Accumulated Depreciation Account,累計折舊科目
-DocType: Certified Consultant,Discuss ID,討論ID
-DocType: Stock Settings,Freeze Stock Entries,凍結庫存項目
-DocType: Program Enrollment,Boarding Student,寄宿學生
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +81,Please enable Applicable on Booking Actual Expenses,請啟用適用於預訂實際費用
-DocType: Asset Finance Book,Expected Value After Useful Life,期望值使用壽命結束後
-DocType: Item,Reorder level based on Warehouse,根據倉庫訂貨點水平
-DocType: Activity Cost,Billing Rate,結算利率
-,Qty to Deliver,數量交付
-DocType: Amazon MWS Settings,Amazon will synch data updated after this date,亞馬遜將同步在此日期之後更新的數據
-,Stock Analytics,庫存分析
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py +72,Lab Test(s) ,實驗室測試
-DocType: Maintenance Visit Purpose,Against Document Detail No,對文件詳細編號
-apps/erpnext/erpnext/regional/__init__.py +11,Deletion is not permitted for country {0},國家{0}不允許刪除
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +111,Party Type is mandatory,黨的類型是強制性
-DocType: Quality Inspection,Outgoing,發送
-DocType: Material Request,Requested For,要求
-DocType: Quotation Item,Against Doctype,針對文檔類型
-apps/erpnext/erpnext/controllers/buying_controller.py +503,{0} {1} is cancelled or closed,{0} {1} 被取消或結案
-DocType: Asset,Calculate Depreciation,計算折舊
-DocType: Delivery Note,Track this Delivery Note against any Project,跟踪此送貨單反對任何項目
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +89,Net Cash from Investing,從投資淨現金
-DocType: Work Order,Work-in-Progress Warehouse,在製品倉庫
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +116,Asset {0} must be submitted,資產{0}必須提交
-DocType: Fee Schedule Program,Total Students,學生總數
-apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56,Attendance Record {0} exists against Student {1},考勤記錄{0}存在針對學生{1}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +390,Reference #{0} dated {1},參考＃ {0}於{1}
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +179,Depreciation Eliminated due to disposal of assets,折舊淘汰因處置資產
-DocType: Employee Transfer,New Employee ID,新員工ID
-DocType: Loan,Member,會員
-DocType: Work Order Item,Work Order Item,工作訂單項目
-DocType: Pricing Rule,Item Code,產品編號
-DocType: Serial No,Warranty / AMC Details,保修/ AMC詳情
-apps/erpnext/erpnext/education/doctype/student_group/student_group.js +119,Select students manually for the Activity based Group,為基於活動的組手動選擇學生
-DocType: Journal Entry,User Remark,用戶備註
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +97,Optimizing routes.,優化路線。
-DocType: Travel Itinerary,Non Diary,非日記
-apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py +14,Cannot create Retention Bonus for left Employees,無法為左員工創建保留獎金
-DocType: Lead,Market Segment,市場分類
-DocType: Agriculture Analysis Criteria,Agriculture Manager,農業經理
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +999,Paid Amount cannot be greater than total negative outstanding amount {0},支付的金額不能超過總負餘額大於{0}
-DocType: Supplier Scorecard Period,Variables,變量
-DocType: Employee Internal Work History,Employee Internal Work History,員工內部工作經歷
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +271,Closing (Dr),關閉（Dr）
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +284,Serial No {0} not in stock,序列號{0}無貨
-apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,稅務模板賣出的交易。
-DocType: Sales Invoice,Write Off Outstanding Amount,核銷額（億元）
-apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27,Account {0} does not match with Company {1},科目{0}與公司{1}不符
-DocType: Education Settings,Current Academic Year,當前學年
-DocType: Education Settings,Current Academic Year,當前學年
-DocType: Stock Settings,Default Stock UOM,預設庫存計量單位
-DocType: Asset,Number of Depreciations Booked,預訂折舊數
-apps/erpnext/erpnext/public/js/pos/pos.html +71,Qty Total,數量總計
-DocType: Employee Education,School/University,學校/大學
-DocType: Sales Invoice Item,Available Qty at Warehouse,有貨數量在倉庫
-apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,帳單金額
-DocType: Share Transfer,(including),（包括）
-DocType: Asset,Double Declining Balance,雙倍餘額遞減
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +188,Closed order cannot be cancelled. Unclose to cancel.,關閉的定單不能被取消。 Unclose取消。
-apps/erpnext/erpnext/config/hr.py +120,Payroll Setup,工資單設置
-DocType: Amazon MWS Settings,Synch Products,同步產品
-DocType: Loyalty Point Entry,Loyalty Program,忠誠計劃
-DocType: Student Guardian,Father,父親
-apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py +59,Support Tickets,支持門票
-apps/erpnext/erpnext/controllers/accounts_controller.py +703,'Update Stock' cannot be checked for fixed asset sale,"""更新庫存"" 無法檢查固定資產銷售"
-DocType: Bank Reconciliation,Bank Reconciliation,銀行對帳
-apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,獲取更新
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +97,{0} {1}: Account {2} does not belong to Company {3},{0} {1}科目{2}不屬於公司{3}
-apps/erpnext/erpnext/stock/doctype/item/item.js +452,Select at least one value from each of the attributes.,從每個屬性中至少選擇一個值。
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +164,Material Request {0} is cancelled or stopped,材料需求{0}被取消或停止
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +219,Dispatch State,派遣國
-apps/erpnext/erpnext/config/hr.py +399,Leave Management,離開管理
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +17,Groups,組
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +51,Group by Account,以科目分群組
-DocType: Purchase Invoice,Hold Invoice,保留發票
-apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +37,Please select Employee,請選擇員工
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +214,Lower Income,較低的收入
-DocType: Restaurant Order Entry,Current Order,當前訂單
-apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +25,Number of serial nos and quantity must be the same,序列號和數量必須相同
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +275,Source and target warehouse cannot be same for row {0},列{0}的來源和目標倉庫不可相同
-DocType: Account,Asset Received But Not Billed,已收到但未收費的資產
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +244,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry",差異科目必須是資產/負債類型的科目，因為此庫存調整是一個開帳分錄
-apps/erpnext/erpnext/hr/doctype/loan/loan.py +116,Disbursed Amount cannot be greater than Loan Amount {0},支付額不能超過貸款金額較大的{0}
-apps/erpnext/erpnext/utilities/user_progress.py +176,Go to Programs,轉到程序
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +212,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},行{0}＃分配的金額{1}不能大於無人認領的金額{2}
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +91,Purchase Order number required for Item {0},所需物品{0}的採購訂單號
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date',“起始日期”必須經過'終止日期'
-apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.js +32,No Staffing Plans found for this Designation,本指定沒有發現人員配備計劃
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1079,Batch {0} of Item {1} is disabled.,項目{1}的批處理{0}已禁用。
-DocType: Leave Policy Detail,Annual Allocation,年度分配
-DocType: Travel Request,Address of Organizer,主辦單位地址
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +68,Select Healthcare Practitioner...,選擇醫療從業者......
-DocType: Employee Boarding Activity,Applicable in the case of Employee Onboarding,適用於員工入職的情況
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39,Cannot change status as student {0} is linked with student application {1},無法改變地位的學生{0}與學生申請鏈接{1}
-DocType: Asset,Fully Depreciated,已提足折舊
-,Stock Projected Qty,存貨預計數量
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +516,Customer {0} does not belong to project {1},客戶{0}不屬於項目{1}
-DocType: Employee Attendance Tool,Marked Attendance HTML,顯著的考勤HTML
-apps/erpnext/erpnext/utilities/activation.py +73,"Quotations are proposals, bids you have sent to your customers",語錄是建議，你已經發送到你的客戶提高出價
-DocType: Sales Invoice,Customer's Purchase Order,客戶採購訂單
-apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +49,Bypass credit check at Sales Order ,在銷售訂單旁通過信用檢查
-DocType: Employee Onboarding Activity,Employee Onboarding Activity,員工入職活動
-DocType: Location,Check if it is a hydroponic unit,檢查它是否是水培單位
-apps/erpnext/erpnext/config/stock.py +112,Serial No and Batch,序列號和批次
-DocType: Warranty Claim,From Company,從公司
-apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +40,Sum of Scores of Assessment Criteria needs to be {0}.,評估標準的得分之和必須是{0}。
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +207,Please set Number of Depreciations Booked,請設置折舊數預訂
-DocType: Supplier Scorecard Period,Calculations,計算
-apps/erpnext/erpnext/public/js/stock_analytics.js +48,Value or Qty,價值或數量
-DocType: Payment Terms Template,Payment Terms,付款條件
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +485,Productions Orders cannot be raised for:,製作訂單不能上調：
-apps/erpnext/erpnext/utilities/user_progress.py +147,Minute,分鐘
-DocType: Purchase Invoice,Purchase Taxes and Charges,購置稅和費
-DocType: Chapter,Meetup Embed HTML,Meetup嵌入HTML
-DocType: Asset,Insured value,保價值
-apps/erpnext/erpnext/utilities/user_progress.py +121,Go to Suppliers,去供應商
-DocType: POS Closing Voucher Taxes,POS Closing Voucher Taxes,POS關閉憑證稅
-,Qty to Receive,未到貨量
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +564,"Start and end dates not in a valid Payroll Period, cannot calculate {0}.",開始日期和結束日期不在有效的工資核算期間內，無法計算{0}。
-DocType: Leave Block List,Leave Block List Allowed,准許的休假區塊清單
-DocType: Grading Scale Interval,Grading Scale Interval,分級分度值
-apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49,Expense Claim for Vehicle Log {0},報銷車輛登錄{0}
-DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,價格上漲率與貼現率的折扣（％）
-DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,價格上漲率與貼現率的折扣（％）
-DocType: Healthcare Service Unit Type,Rate / UOM,費率/ UOM
-apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,所有倉庫
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1303,No {0} found for Inter Company Transactions.,Inter公司沒有找到{0}。
-DocType: Travel Itinerary,Rented Car,租車
-apps/erpnext/erpnext/public/js/hub/components/profile_dialog.js +15,About your Company,關於貴公司
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +144,Credit To account must be a Balance Sheet account,貸方科目必須是資產負債表科目
-DocType: Donor,Donor,捐贈者
-DocType: Global Defaults,Disable In Words,禁用詞
-apps/erpnext/erpnext/stock/doctype/item/item.py +74,Item Code is mandatory because Item is not automatically numbered,產品編號是強制性的，因為項目沒有自動編號
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +102,Quotation {0} not of type {1},報價{0}非為{1}類型
-DocType: Maintenance Schedule Item,Maintenance Schedule Item,維護計劃項目
-DocType: Sales Order,%  Delivered,％交付
-apps/erpnext/erpnext/education/doctype/fees/fees.js +108,Please set the Email ID for the Student to send the Payment Request,請設置學生的電子郵件ID以發送付款請求
-DocType: Patient,Medical History,醫學史
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +167,Bank Overdraft Account,銀行透支戶口
-DocType: Practitioner Schedule,Schedule Name,計劃名稱
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +302,Sales Pipeline by Stage,按階段劃分的銷售渠道
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +49,Make Salary Slip,製作工資單
-DocType: Currency Exchange,For Buying,為了購買
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +897,Add All Suppliers,添加所有供應商
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +95,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,行＃{0}：分配金額不能大於未結算金額。
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +84,Browse BOM,瀏覽BOM
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +165,Secured Loans,抵押貸款
-DocType: Purchase Invoice,Edit Posting Date and Time,編輯投稿時間
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +106,Please set Depreciation related Accounts in Asset Category {0} or Company {1},請設置在資產類別{0}或公司折舊相關科目{1}
-DocType: Lab Test Groups,Normal Range,普通範圍
-DocType: Academic Term,Academic Year,學年
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +79,Available Selling,可用銷售
-DocType: Loyalty Point Entry Redemption,Loyalty Point Entry Redemption,忠誠度積分兌換
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +179,Opening Balance Equity,期初餘額權益
-DocType: Purchase Invoice,N,ñ
-apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,剩餘
-DocType: Appraisal,Appraisal,評價
-DocType: Loan,Loan Account,貸款科目
-DocType: Purchase Invoice,GST Details,消費稅細節
-apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py +6,This is based on transactions against this Healthcare Practitioner.,這是基於針對此醫療保健從業者的交易。
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +156,Email sent to supplier {0},電子郵件發送到供應商{0}
-DocType: Item,Default Sales Unit of Measure,默認銷售單位
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +12,Academic Year: ,學年：
-DocType: Inpatient Record,Admission Schedule Date,入學時間表日期
-DocType: Subscription,Past Due Date,過去的截止日期
-apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py +19,Not allow to set alternative item for the item {0},不允許為項目{0}設置替代項目
-apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,日期重複
-apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,授權簽字人
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +65,Create Fees,創造費用
-DocType: Project,Total Purchase Cost (via Purchase Invoice),總購買成本（通過採購發票）
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +549,Select Quantity,選擇數量
-DocType: Loyalty Point Entry,Loyalty Points,忠誠度積分
-DocType: Customs Tariff Number,Customs Tariff Number,海關稅則號
-DocType: Patient Appointment,Patient Appointment,患者預約
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,審批角色作為角色的規則適用於不能相同
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +65,Unsubscribe from this Email Digest,從該電子郵件摘要退訂
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +887,Get Suppliers By,獲得供應商
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +187,{0} not found for Item {1},找不到項目{1} {0}
-apps/erpnext/erpnext/utilities/user_progress.py +197,Go to Courses,去課程
-DocType: Accounts Settings,Show Inclusive Tax In Print,在打印中顯示包含稅
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +17,"Bank Account, From Date and To Date are Mandatory",銀行科目，從日期到日期是強制性的
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +29,Message Sent,發送訊息
-apps/erpnext/erpnext/accounts/doctype/account/account.py +105,Account with child nodes cannot be set as ledger,科目與子節點不能被設置為分類帳
-DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,價目表貨幣被換算成客戶基礎貨幣的匯率
-DocType: Purchase Invoice Item,Net Amount (Company Currency),淨金額（公司貨幣）
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +223,Total advance amount cannot be greater than total sanctioned amount,總預付金額不得超過全部認可金額
-DocType: Salary Slip,Hour Rate,小時率
-DocType: Stock Settings,Item Naming By,產品命名規則
-apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46,Another Period Closing Entry {0} has been made after {1},另一個期末錄入{0}作出後{1}
-DocType: Work Order,Material Transferred for Manufacturing,物料轉倉用於製造
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +49,Account {0} does not exists,科目{0}不存在
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1608,Select Loyalty Program,選擇忠誠度計劃
-DocType: Project,Project Type,專案類型
-apps/erpnext/erpnext/projects/doctype/task/task.py +157,Child Task exists for this Task. You can not delete this Task.,子任務存在這個任務。你不能刪除這個任務。
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +17,Either target qty or target amount is mandatory.,無論是數量目標或目標量是強制性的。
-apps/erpnext/erpnext/config/projects.py +56,Cost of various activities,各種活動的費用
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60,"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}",設置活動為{0}，因為附連到下面的銷售者的僱員不具有用戶ID {1}
-DocType: Timesheet,Billing Details,結算明細
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +163,Source and target warehouse must be different,源和目標倉庫必須是不同的
-apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +140,Payment Failed. Please check your GoCardless Account for more details,支付失敗。請檢查您的GoCardless帳戶以了解更多詳情
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},不允許更新比{0}舊的庫存交易
-DocType: BOM,Inspection Required,需要檢驗
-DocType: Purchase Invoice Item,PR Detail,詳細新聞稿
-apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py +17,Enter the Bank Guarantee Number before submittting.,在提交之前輸入銀行保證號碼。
-DocType: Driving License Category,Class,類
-DocType: Sales Order,Fully Billed,完全開票
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +387,Work Order cannot be raised against a Item Template,工作訂單不能針對項目模板產生
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101,Shipping rule only applicable for Buying,運費規則只適用於購買
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,手頭現金
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +143,Delivery warehouse required for stock item {0},需要的庫存項目交割倉庫{0}
-DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),包裹的總重量。通常為淨重+包裝材料的重量。 （用於列印）
-DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,具有此角色的用戶可以設置凍結科目，並新增/修改對凍結科目的會計分錄
-DocType: Vital Signs,Cuts,削減
-DocType: Serial No,Is Cancelled,被註銷
-DocType: Student Group,Group Based On,基於組
-DocType: Student Group,Group Based On,基於組
-DocType: Journal Entry,Bill Date,帳單日期
-DocType: Healthcare Settings,Laboratory SMS Alerts,實驗室短信
-apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20,"Service Item,Type,frequency and expense amount are required",服務項目，類型，頻率和消費金額要求
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:",即使有更高優先級的多個定價規則，然後按照內部優先級應用：
-DocType: Plant Analysis Criteria,Plant Analysis Criteria,植物分析標準
-DocType: Supplier,Supplier Details,供應商詳細資訊
-DocType: Setup Progress,Setup Progress,設置進度
-DocType: Expense Claim,Approval Status,審批狀態
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35,From value must be less than to value in row {0},來源值必須小於列{0}的值
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135,Wire Transfer,電匯
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +93,Check all,全面檢查
-,Issued Items Against Work Order,針對工單發布物品
-,BOM Stock Calculated,BOM庫存計算
-DocType: Vehicle Log,Invoice Ref,發票編號
-DocType: Company,Default Income Account,預設收入科目
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +39,Unclosed Fiscal Years Profit / Loss (Credit),未關閉的財年利潤/損失（信用）
-DocType: Sales Invoice,Time Sheets,考勤表
-DocType: Healthcare Service Unit Type,Change In Item,更改項目
-DocType: Payment Gateway Account,Default Payment Request Message,預設的付款請求訊息
-DocType: Retention Bonus,Bonus Amount,獎金金額
-DocType: Item Group,Check this if you want to show in website,勾選本項以顯示在網頁上
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +376,Balance ({0}),餘額（{0}）
-DocType: Loyalty Point Entry,Redeem Against,兌換
-apps/erpnext/erpnext/config/accounts.py +130,Banking and Payments,銀行和支付
-apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py +99,Please enter API Consumer Key,請輸入API使用者密鑰
-,Welcome to ERPNext,歡迎來到ERPNext
-apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,主導報價
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +34,Email Reminders will be sent to all parties with email contacts,電子郵件提醒將通過電子郵件聯繫方式發送給各方
-DocType: Project,Twice Daily,每天兩次
-DocType: Inpatient Record,A Negative,一個負面的
-apps/erpnext/erpnext/templates/includes/product_list.js +45,Nothing more to show.,沒有更多的表現。
-DocType: Lead,From Customer,從客戶
-apps/erpnext/erpnext/demo/setup/setup_data.py +340,Calls,電話
-apps/erpnext/erpnext/utilities/user_progress.py +143,A Product,一個產品
-DocType: Employee Tax Exemption Declaration,Declarations,聲明
-apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,製作費用表
-DocType: Purchase Order Item Supplied,Stock UOM,庫存計量單位
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +263,Purchase Order {0} is not submitted,採購訂單{0}未提交
-DocType: Account,Expenses Included In Asset Valuation,資產評估中包含的費用
-DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),成人的正常參考範圍是16-20次呼吸/分鐘（RCP 2012）
-DocType: Customs Tariff Number,Tariff Number,稅則號
-DocType: Work Order Item,Available Qty at WIP Warehouse,在WIP倉庫可用的數量
-apps/erpnext/erpnext/stock/doctype/item/item.js +41,Projected,預計
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +233,Serial No {0} does not belong to Warehouse {1},序列號{0}不屬於倉庫{1}
-apps/erpnext/erpnext/controllers/status_updater.py +180,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,注：系統將不檢查過交付和超額預訂的項目{0}的數量或金額為0
-DocType: Notification Control,Quotation Message,報價訊息
-DocType: Issue,Opening Date,開幕日期
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +89,Please save the patient first,請先保存患者
-apps/erpnext/erpnext/education/api.py +80,Attendance has been marked successfully.,出席已成功標記。
-DocType: Delivery Note,GST Vehicle Type,GST車型
-DocType: Soil Texture,Silt Composition (%),粉塵成分（％）
-DocType: Journal Entry,Remark,備註
-DocType: Healthcare Settings,Avoid Confirmation,避免確認
-DocType: Purchase Receipt Item,Rate and Amount,率及金額
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +177,Account Type for {0} must be {1},科目類型為{0}必須{1}
-apps/erpnext/erpnext/config/hr.py +34,Leaves and Holiday,休假及假日
-DocType: Education Settings,Current Academic Term,當前學術期限
-DocType: Education Settings,Current Academic Term,當前學術期限
-DocType: Sales Order,Not Billed,不發單
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +77,Both Warehouse must belong to same Company,這兩個倉庫必須屬於同一個公司
-DocType: Employee Grade,Default Leave Policy,默認離開政策
-DocType: Shopify Settings,Shop URL,商店網址
-apps/erpnext/erpnext/public/js/templates/contact_list.html +34,No contacts added yet.,尚未新增聯絡人。
-DocType: Purchase Invoice Item,Landed Cost Voucher Amount,到岸成本憑證金額
-,Item Balance (Simple),物品餘額（簡單）
-apps/erpnext/erpnext/config/accounts.py +19,Bills raised by Suppliers.,由供應商提出的帳單。
-DocType: POS Profile,Write Off Account,核銷帳戶
-DocType: Patient Appointment,Get prescribed procedures,獲取規定的程序
-DocType: Sales Invoice,Redemption Account,贖回科目
-DocType: Purchase Invoice Item,Discount Amount,折扣金額
-DocType: Purchase Invoice,Return Against Purchase Invoice,回到對採購發票
-DocType: Item,Warranty Period (in days),保修期限（天數）
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,與關係Guardian1
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +879,Please select BOM against item {0},請選擇物料{0}的物料清單
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18,Make Invoices,製作發票
-DocType: Shopping Cart Settings,Show Stock Quantity,顯示庫存數量
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +77,Net Cash from Operations,從運營的淨現金
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,項目4
-DocType: Student Admission,Admission End Date,錄取結束日期
-DocType: Journal Entry Account,Journal Entry Account,日記帳分錄帳號
-apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3,Student Group,學生組
-DocType: Shopping Cart Settings,Quotation Series,報價系列
-apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +60,"An item exists with same name ({0}), please change the item group name or rename the item",具有相同名稱的項目存在（ {0} ） ，請更改項目群組名或重新命名該項目
-DocType: Soil Analysis Criteria,Soil Analysis Criteria,土壤分析標準
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2052,Please select customer,請選擇客戶
-DocType: C-Form,I,一世
-DocType: Company,Asset Depreciation Cost Center,資產折舊成本中心
-DocType: Production Plan Sales Order,Sales Order Date,銷售訂單日期
-DocType: Sales Invoice Item,Delivered Qty,交付數量
-DocType: Assessment Plan,Assessment Plan,評估計劃
-DocType: Travel Request,Fully Sponsored,完全贊助
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +28,Reverse Journal Entry,反向日記帳分錄
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90,Customer {0} is created.,客戶{0}已創建。
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,目前任何倉庫沒有庫存
-,Payment Period Based On Invoice Date,基於發票日的付款期
-DocType: Sample Collection,No. of print,打印數量
-DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,酒店房間預訂項目
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +59,Missing Currency Exchange Rates for {0},缺少貨幣匯率{0}
-DocType: Employee Health Insurance,Health Insurance Name,健康保險名稱
-DocType: Assessment Plan,Examiner,檢查員
-DocType: Journal Entry,Stock Entry,存貨分錄
-DocType: Payment Entry,Payment References,付款參考
-DocType: Subscription Plan,"Number of intervals for the interval field e.g if Interval is 'Days' and Billing Interval Count is 3, invoices will be generated every 3 days",間隔字段的間隔數，例如，如果間隔為&#39;天數&#39;並且計費間隔計數為3，則會每3天生成一次發票
-DocType: Clinical Procedure Template,Allow Stock Consumption,允許庫存消耗
-DocType: Asset,Insurance Details,保險詳情
-DocType: Account,Payable,支付
-DocType: Share Balance,Share Type,分享類型
-apps/erpnext/erpnext/hr/doctype/loan/loan.py +123,Please enter Repayment Periods,請輸入還款期
-apps/erpnext/erpnext/shopping_cart/cart.py +378,Debtors ({0}),債務人（{0}）
-DocType: Pricing Rule,Margin,餘量
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,新客戶
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +90,Appointment {0} and Sales Invoice {1} cancelled,約會{0}和銷售發票{1}已取消
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +43,Opportunities by lead source,鉛來源的機會
-DocType: Appraisal Goal,Weightage (%),權重（％）
-DocType: Bank Reconciliation Detail,Clearance Date,清拆日期
-apps/erpnext/erpnext/stock/doctype/item/item.py +742,"Asset is already exists against the item {0}, you cannot change the has serial no value",資產已針對商品{0}存在，您無法更改已連續編號的值
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +10,Assessment Report,評估報告
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +26,Get Employees,獲得員工
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +72,Gross Purchase Amount is mandatory,總消費金額是強制性
-apps/erpnext/erpnext/setup/doctype/company/company.js +115,Company name not same,公司名稱不一樣
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +114,Party is mandatory,黨是強制性
-DocType: Topic,Topic Name,主題名稱
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +311,Please set default template for Leave Approval Notification in HR Settings.,請在人力資源設置中為離職審批通知設置默認模板。
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +38,Atleast one of the Selling or Buying must be selected,至少需選擇銷售或購買
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +308,Select an employee to get the employee advance.,選擇一名員工以推進員工。
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56,Please select a valid Date,請選擇一個有效的日期
-apps/erpnext/erpnext/public/js/setup_wizard.js +36,Select the nature of your business.,選擇您的業務的性質。
-DocType: Lab Test Template,"Single for results which require only a single input, result UOM and normal value 
+Customer Type,客戶類型
+Leave Allocation,排假
+Recipient Message And Payment Details,收件人郵件和付款細節
+Source DocType,源DocType,
+Open a new ticket,打開一張新票
+Trainer Email,教練電子郵件
+Transporter,運輸車
+Material Requests {0} created,{0}物料需求已建立
+No of People,沒有人
+Template of terms or contract.,模板條款或合同。
+Address and Contact,地址和聯絡方式
+Is Account Payable,為應付帳款
+Stock cannot be updated against Purchase Receipt {0},庫存不能對外購入庫單進行更新{0}
+Auto close Issue after 7 days,7天之後自動關閉問題
+"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}",假，不是之前分配{0}，因為休假餘額已經結轉轉發在未來的假期分配記錄{1}
+Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),註：由於/參考日期由{0}天超過了允許客戶的信用天數（S）
+Student Applicant,學生申請
+Hub Tracked Item,Hub跟踪物品
+Accumulated Depreciation Account,累計折舊科目
+Discuss ID,討論ID,
+Freeze Stock Entries,凍結庫存項目
+Boarding Student,寄宿學生
+Please enable Applicable on Booking Actual Expenses,請啟用適用於預訂實際費用
+Expected Value After Useful Life,期望值使用壽命結束後
+Reorder level based on Warehouse,根據倉庫訂貨點水平
+Billing Rate,結算利率
+Qty to Deliver,數量交付
+Amazon will synch data updated after this date,亞馬遜將同步在此日期之後更新的數據
+Stock Analytics,庫存分析
+Lab Test(s) ,實驗室測試
+Against Document Detail No,對文件詳細編號
+Deletion is not permitted for country {0},國家{0}不允許刪除
+Party Type is mandatory,黨的類型是強制性
+Outgoing,發送
+Requested For,要求
+Against Doctype,針對文檔類型
+{0} {1} is cancelled or closed,{0} {1} 被取消或結案
+Calculate Depreciation,計算折舊
+Track this Delivery Note against any Project,跟踪此送貨單反對任何項目
+Net Cash from Investing,從投資淨現金
+Work-in-Progress Warehouse,在製品倉庫
+Asset {0} must be submitted,資產{0}必須提交
+Total Students,學生總數
+Attendance Record {0} exists against Student {1},考勤記錄{0}存在針對學生{1}
+Reference #{0} dated {1},參考＃ {0}於{1}
+Depreciation Eliminated due to disposal of assets,折舊淘汰因處置資產
+New Employee ID,新員工ID,
+Member,會員
+Work Order Item,工作訂單項目
+Item Code,產品編號
+Warranty / AMC Details,保修/ AMC詳情
+Select students manually for the Activity based Group,為基於活動的組手動選擇學生
+User Remark,用戶備註
+Optimizing routes.,優化路線。
+Non Diary,非日記
+Cannot create Retention Bonus for left Employees,無法為左員工創建保留獎金
+Market Segment,市場分類
+Agriculture Manager,農業經理
+Paid Amount cannot be greater than total negative outstanding amount {0},支付的金額不能超過總負餘額大於{0}
+Variables,變量
+Employee Internal Work History,員工內部工作經歷
+Closing (Dr),關閉（Dr）
+Serial No {0} not in stock,序列號{0}無貨
+Tax template for selling transactions.,稅務模板賣出的交易。
+Write Off Outstanding Amount,核銷額（億元）
+Account {0} does not match with Company {1},科目{0}與公司{1}不符
+Current Academic Year,當前學年
+Current Academic Year,當前學年
+Default Stock UOM,預設庫存計量單位
+Number of Depreciations Booked,預訂折舊數
+Qty Total,數量總計
+School/University,學校/大學
+Available Qty at Warehouse,有貨數量在倉庫
+Billed Amount,帳單金額
+(including),（包括）
+Double Declining Balance,雙倍餘額遞減
+Closed order cannot be cancelled. Unclose to cancel.,關閉的定單不能被取消。 Unclose取消。
+Payroll Setup,工資單設置
+Synch Products,同步產品
+Loyalty Program,忠誠計劃
+Father,父親
+Support Tickets,支持門票
+'Update Stock' cannot be checked for fixed asset sale,"""更新庫存"" 無法檢查固定資產銷售"
+Bank Reconciliation,銀行對帳
+Get Updates,獲取更新
+{0} {1}: Account {2} does not belong to Company {3},{0} {1}科目{2}不屬於公司{3}
+Select at least one value from each of the attributes.,從每個屬性中至少選擇一個值。
+Material Request {0} is cancelled or stopped,材料需求{0}被取消或停止
+Dispatch State,派遣國
+Leave Management,離開管理
+Groups,組
+Group by Account,以科目分群組
+Hold Invoice,保留發票
+Please select Employee,請選擇員工
+Lower Income,較低的收入
+Current Order,當前訂單
+Number of serial nos and quantity must be the same,序列號和數量必須相同
+Source and target warehouse cannot be same for row {0},列{0}的來源和目標倉庫不可相同
+Asset Received But Not Billed,已收到但未收費的資產
+"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry",差異科目必須是資產/負債類型的科目，因為此庫存調整是一個開帳分錄
+Disbursed Amount cannot be greater than Loan Amount {0},支付額不能超過貸款金額較大的{0}
+Go to Programs,轉到程序
+Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},行{0}＃分配的金額{1}不能大於無人認領的金額{2}
+Purchase Order number required for Item {0},所需物品{0}的採購訂單號
+'From Date' must be after 'To Date',“起始日期”必須經過'終止日期'
+No Staffing Plans found for this Designation,本指定沒有發現人員配備計劃
+Batch {0} of Item {1} is disabled.,項目{1}的批處理{0}已禁用。
+Annual Allocation,年度分配
+Address of Organizer,主辦單位地址
+Select Healthcare Practitioner...,選擇醫療從業者......
+Applicable in the case of Employee Onboarding,適用於員工入職的情況
+Cannot change status as student {0} is linked with student application {1},無法改變地位的學生{0}與學生申請鏈接{1}
+Fully Depreciated,已提足折舊
+Stock Projected Qty,存貨預計數量
+Customer {0} does not belong to project {1},客戶{0}不屬於項目{1}
+Marked Attendance HTML,顯著的考勤HTML,
+"Quotations are proposals, bids you have sent to your customers",語錄是建議，你已經發送到你的客戶提高出價
+Customer's Purchase Order,客戶採購訂單
+Bypass credit check at Sales Order ,在銷售訂單旁通過信用檢查
+Employee Onboarding Activity,員工入職活動
+Check if it is a hydroponic unit,檢查它是否是水培單位
+Serial No and Batch,序列號和批次
+From Company,從公司
+Sum of Scores of Assessment Criteria needs to be {0}.,評估標準的得分之和必須是{0}。
+Please set Number of Depreciations Booked,請設置折舊數預訂
+Calculations,計算
+Value or Qty,價值或數量
+Payment Terms,付款條件
+Productions Orders cannot be raised for:,製作訂單不能上調：
+Minute,分鐘
+Purchase Taxes and Charges,購置稅和費
+Meetup Embed HTML,Meetup嵌入HTML,
+Insured value,保價值
+Go to Suppliers,去供應商
+POS Closing Voucher Taxes,POS關閉憑證稅
+Qty to Receive,未到貨量
+"Start and end dates not in a valid Payroll Period, cannot calculate {0}.",開始日期和結束日期不在有效的工資核算期間內，無法計算{0}。
+Leave Block List Allowed,准許的休假區塊清單
+Grading Scale Interval,分級分度值
+Expense Claim for Vehicle Log {0},報銷車輛登錄{0}
+Discount (%) on Price List Rate with Margin,價格上漲率與貼現率的折扣（％）
+Discount (%) on Price List Rate with Margin,價格上漲率與貼現率的折扣（％）
+Rate / UOM,費率/ UOM,
+All Warehouses,所有倉庫
+No {0} found for Inter Company Transactions.,Inter公司沒有找到{0}。
+Rented Car,租車
+About your Company,關於貴公司
+Credit To account must be a Balance Sheet account,貸方科目必須是資產負債表科目
+Donor,捐贈者
+Disable In Words,禁用詞
+Item Code is mandatory because Item is not automatically numbered,產品編號是強制性的，因為項目沒有自動編號
+Quotation {0} not of type {1},報價{0}非為{1}類型
+Maintenance Schedule Item,維護計劃項目
+%  Delivered,％交付
+Please set the Email ID for the Student to send the Payment Request,請設置學生的電子郵件ID以發送付款請求
+Medical History,醫學史
+Bank Overdraft Account,銀行透支戶口
+Schedule Name,計劃名稱
+Sales Pipeline by Stage,按階段劃分的銷售渠道
+Make Salary Slip,製作工資單
+For Buying,為了購買
+Add All Suppliers,添加所有供應商
+Row #{0}: Allocated Amount cannot be greater than outstanding amount.,行＃{0}：分配金額不能大於未結算金額。
+Browse BOM,瀏覽BOM,
+Secured Loans,抵押貸款
+Edit Posting Date and Time,編輯投稿時間
+Please set Depreciation related Accounts in Asset Category {0} or Company {1},請設置在資產類別{0}或公司折舊相關科目{1}
+Normal Range,普通範圍
+Academic Year,學年
+Available Selling,可用銷售
+Loyalty Point Entry Redemption,忠誠度積分兌換
+Opening Balance Equity,期初餘額權益
+N,ñ
+Remaining,剩餘
+Appraisal,評價
+Loan Account,貸款科目
+GST Details,消費稅細節
+This is based on transactions against this Healthcare Practitioner.,這是基於針對此醫療保健從業者的交易。
+Email sent to supplier {0},電子郵件發送到供應商{0}
+Default Sales Unit of Measure,默認銷售單位
+Academic Year: ,學年：
+Admission Schedule Date,入學時間表日期
+Past Due Date,過去的截止日期
+Not allow to set alternative item for the item {0},不允許為項目{0}設置替代項目
+Date is repeated,日期重複
+Authorized Signatory,授權簽字人
+Create Fees,創造費用
+Total Purchase Cost (via Purchase Invoice),總購買成本（通過採購發票）
+Select Quantity,選擇數量
+Loyalty Points,忠誠度積分
+Customs Tariff Number,海關稅則號
+Patient Appointment,患者預約
+Approving Role cannot be same as role the rule is Applicable To,審批角色作為角色的規則適用於不能相同
+Unsubscribe from this Email Digest,從該電子郵件摘要退訂
+Get Suppliers By,獲得供應商
+{0} not found for Item {1},找不到項目{1} {0}
+Go to Courses,去課程
+Show Inclusive Tax In Print,在打印中顯示包含稅
+"Bank Account, From Date and To Date are Mandatory",銀行科目，從日期到日期是強制性的
+Message Sent,發送訊息
+Account with child nodes cannot be set as ledger,科目與子節點不能被設置為分類帳
+Rate at which Price list currency is converted to customer's base currency,價目表貨幣被換算成客戶基礎貨幣的匯率
+Net Amount (Company Currency),淨金額（公司貨幣）
+Total advance amount cannot be greater than total sanctioned amount,總預付金額不得超過全部認可金額
+Hour Rate,小時率
+Item Naming By,產品命名規則
+Another Period Closing Entry {0} has been made after {1},另一個期末錄入{0}作出後{1}
+Material Transferred for Manufacturing,物料轉倉用於製造
+Account {0} does not exists,科目{0}不存在
+Select Loyalty Program,選擇忠誠度計劃
+Project Type,專案類型
+Child Task exists for this Task. You can not delete this Task.,子任務存在這個任務。你不能刪除這個任務。
+Either target qty or target amount is mandatory.,無論是數量目標或目標量是強制性的。
+Cost of various activities,各種活動的費用
+"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}",設置活動為{0}，因為附連到下面的銷售者的僱員不具有用戶ID {1}
+Billing Details,結算明細
+Source and target warehouse must be different,源和目標倉庫必須是不同的
+Payment Failed. Please check your GoCardless Account for more details,支付失敗。請檢查您的GoCardless帳戶以了解更多詳情
+Not allowed to update stock transactions older than {0},不允許更新比{0}舊的庫存交易
+Inspection Required,需要檢驗
+PR Detail,詳細新聞稿
+Enter the Bank Guarantee Number before submittting.,在提交之前輸入銀行保證號碼。
+Class,類
+Fully Billed,完全開票
+Work Order cannot be raised against a Item Template,工作訂單不能針對項目模板產生
+Shipping rule only applicable for Buying,運費規則只適用於購買
+Cash In Hand,手頭現金
+Delivery warehouse required for stock item {0},需要的庫存項目交割倉庫{0}
+The gross weight of the package. Usually net weight + packaging material weight. (for print),包裹的總重量。通常為淨重+包裝材料的重量。 （用於列印）
+Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,具有此角色的用戶可以設置凍結科目，並新增/修改對凍結科目的會計分錄
+Cuts,削減
+Is Cancelled,被註銷
+Group Based On,基於組
+Group Based On,基於組
+Bill Date,帳單日期
+Laboratory SMS Alerts,實驗室短信
+"Service Item,Type,frequency and expense amount are required",服務項目，類型，頻率和消費金額要求
+"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:",即使有更高優先級的多個定價規則，然後按照內部優先級應用：
+Plant Analysis Criteria,植物分析標準
+Supplier Details,供應商詳細資訊
+Setup Progress,設置進度
+Approval Status,審批狀態
+From value must be less than to value in row {0},來源值必須小於列{0}的值
+Wire Transfer,電匯
+Check all,全面檢查
+Issued Items Against Work Order,針對工單發布物品
+BOM Stock Calculated,BOM庫存計算
+Invoice Ref,發票編號
+Default Income Account,預設收入科目
+Unclosed Fiscal Years Profit / Loss (Credit),未關閉的財年利潤/損失（信用）
+Time Sheets,考勤表
+Change In Item,更改項目
+Default Payment Request Message,預設的付款請求訊息
+Bonus Amount,獎金金額
+Check this if you want to show in website,勾選本項以顯示在網頁上
+Balance ({0}),餘額（{0}）
+Redeem Against,兌換
+Banking and Payments,銀行和支付
+Please enter API Consumer Key,請輸入API使用者密鑰
+Welcome to ERPNext,歡迎來到ERPNext,
+Lead to Quotation,主導報價
+Email Reminders will be sent to all parties with email contacts,電子郵件提醒將通過電子郵件聯繫方式發送給各方
+Twice Daily,每天兩次
+A Negative,一個負面的
+Nothing more to show.,沒有更多的表現。
+From Customer,從客戶
+Calls,電話
+A Product,一個產品
+Declarations,聲明
+Make Fee Schedule,製作費用表
+Stock UOM,庫存計量單位
+Purchase Order {0} is not submitted,採購訂單{0}未提交
+Expenses Included In Asset Valuation,資產評估中包含的費用
+Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),成人的正常參考範圍是16-20次呼吸/分鐘（RCP 2012）
+Tariff Number,稅則號
+Available Qty at WIP Warehouse,在WIP倉庫可用的數量
+Projected,預計
+Serial No {0} does not belong to Warehouse {1},序列號{0}不屬於倉庫{1}
+Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,注：系統將不檢查過交付和超額預訂的項目{0}的數量或金額為0,
+Quotation Message,報價訊息
+Opening Date,開幕日期
+Please save the patient first,請先保存患者
+Attendance has been marked successfully.,出席已成功標記。
+GST Vehicle Type,GST車型
+Silt Composition (%),粉塵成分（％）
+Remark,備註
+Avoid Confirmation,避免確認
+Rate and Amount,率及金額
+Account Type for {0} must be {1},科目類型為{0}必須{1}
+Leaves and Holiday,休假及假日
+Current Academic Term,當前學術期限
+Current Academic Term,當前學術期限
+Not Billed,不發單
+Both Warehouse must belong to same Company,這兩個倉庫必須屬於同一個公司
+Default Leave Policy,默認離開政策
+Shop URL,商店網址
+No contacts added yet.,尚未新增聯絡人。
+Landed Cost Voucher Amount,到岸成本憑證金額
+Item Balance (Simple),物品餘額（簡單）
+Bills raised by Suppliers.,由供應商提出的帳單。
+Write Off Account,核銷帳戶
+Get prescribed procedures,獲取規定的程序
+Redemption Account,贖回科目
+Discount Amount,折扣金額
+Return Against Purchase Invoice,回到對採購發票
+Warranty Period (in days),保修期限（天數）
+Relation with Guardian1,與關係Guardian1,
+Please select BOM against item {0},請選擇物料{0}的物料清單
+Make Invoices,製作發票
+Show Stock Quantity,顯示庫存數量
+Net Cash from Operations,從運營的淨現金
+Item 4,項目4,
+Admission End Date,錄取結束日期
+Journal Entry Account,日記帳分錄帳號
+Student Group,學生組
+Quotation Series,報價系列
+"An item exists with same name ({0}), please change the item group name or rename the item",具有相同名稱的項目存在（ {0} ） ，請更改項目群組名或重新命名該項目
+Soil Analysis Criteria,土壤分析標準
+Please select customer,請選擇客戶
+I,一世
+Asset Depreciation Cost Center,資產折舊成本中心
+Sales Order Date,銷售訂單日期
+Delivered Qty,交付數量
+Assessment Plan,評估計劃
+Fully Sponsored,完全贊助
+Reverse Journal Entry,反向日記帳分錄
+Customer {0} is created.,客戶{0}已創建。
+ Currently no stock available in any warehouse,目前任何倉庫沒有庫存
+Payment Period Based On Invoice Date,基於發票日的付款期
+No. of print,打印數量
+Hotel Room Reservation Item,酒店房間預訂項目
+Missing Currency Exchange Rates for {0},缺少貨幣匯率{0}
+Health Insurance Name,健康保險名稱
+Examiner,檢查員
+Stock Entry,存貨分錄
+Payment References,付款參考
+"Number of intervals for the interval field e.g if Interval is 'Days' and Billing Interval Count is 3, invoices will be generated every 3 days",間隔字段的間隔數，例如，如果間隔為&#39;天數&#39;並且計費間隔計數為3，則會每3天生成一次發票
+Allow Stock Consumption,允許庫存消耗
+Insurance Details,保險詳情
+Payable,支付
+Share Type,分享類型
+Please enter Repayment Periods,請輸入還款期
+Debtors ({0}),債務人（{0}）
+Margin,餘量
+New Customers,新客戶
+Appointment {0} and Sales Invoice {1} cancelled,約會{0}和銷售發票{1}已取消
+Opportunities by lead source,鉛來源的機會
+Weightage (%),權重（％）
+Clearance Date,清拆日期
+"Asset is already exists against the item {0}, you cannot change the has serial no value",資產已針對商品{0}存在，您無法更改已連續編號的值
+Assessment Report,評估報告
+Get Employees,獲得員工
+Gross Purchase Amount is mandatory,總消費金額是強制性
+Company name not same,公司名稱不一樣
+Party is mandatory,黨是強制性
+Topic Name,主題名稱
+Please set default template for Leave Approval Notification in HR Settings.,請在人力資源設置中為離職審批通知設置默認模板。
+Atleast one of the Selling or Buying must be selected,至少需選擇銷售或購買
+Select an employee to get the employee advance.,選擇一名員工以推進員工。
+Please select a valid Date,請選擇一個有效的日期
+Select the nature of your business.,選擇您的業務的性質。
+"Single for results which require only a single input, result UOM and normal value 
 <br>
-Compound for results which require multiple input fields with corresponding event names, result UOMs and normal values
+Compound for results which require multiple input fields with corresponding event names, result UOMs and normal values,
 <br>
 Descriptive for tests which have multiple result components and corresponding result entry fields. 
 <br>
 Grouped for test templates which are a group of other test templates.
 <br>
 No Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.",單一的結果只需要一個輸入，結果UOM和正常值<br>對於需要具有相應事件名稱的多個輸入字段的結果的化合物，結果為UOM和正常值<br>具有多個結果組件和相應結果輸入字段的測試的描述。 <br>分組為一組其他測試模板的測試模板。 <br>沒有沒有結果的測試結果。此外，沒有創建實驗室測試。例如。分組測試的子測試。
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +87,Row #{0}: Duplicate entry in References {1} {2},行＃{0}：引用{1} {2}中的重複條目
-apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,生產作業於此進行。
-apps/erpnext/erpnext/education/doctype/instructor/instructor.js +39,As Examiner,作為考官
-DocType: Company,Default Expense Claim Payable Account,默認費用索賠應付帳款
-DocType: Appointment Type,Default Duration,默認時長
-DocType: BOM Explosion Item,Source Warehouse,來源倉庫
-DocType: Installation Note,Installation Date,安裝日期
-apps/erpnext/erpnext/controllers/accounts_controller.py +677,Row #{0}: Asset {1} does not belong to company {2},行＃{0}：資產{1}不屬於公司{2}
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +114,Sales Invoice {0} created,已創建銷售發票{0}
-DocType: Employee,Confirmation Date,確認日期
-DocType: Inpatient Occupancy,Check Out,查看
-DocType: C-Form,Total Invoiced Amount,發票總金額
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +51,Min Qty can not be greater than Max Qty,最小數量不能大於最大數量
-DocType: Account,Accumulated Depreciation,累計折舊
-DocType: Supplier Scorecard Scoring Standing,Standing Name,常務名稱
-DocType: Stock Entry,Customer or Supplier Details,客戶或供應商詳細訊息
-DocType: Asset Value Adjustment,Current Asset Value,流動資產價值
-DocType: Travel Request,Travel Funding,旅行資助
-DocType: Crop Cycle,A link to all the Locations in which the Crop is growing,指向作物生長的所有位置的鏈接
-DocType: Lead,Lead Owner,主導擁有者
-DocType: Production Plan,Sales Orders Detail,銷售訂單明細
-DocType: Bin,Requested Quantity,要求的數量
-DocType: Fees,EDU-FEE-.YYYY.-,EDU-收費.YYYY.-
-DocType: Patient,Marital Status,婚姻狀況
-DocType: Stock Settings,Auto Material Request,自動物料需求
-DocType: Woocommerce Settings,API consumer secret,API消費者秘密
-DocType: Delivery Note Item,Available Batch Qty at From Warehouse,在從倉庫可用的批次數量
-DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,工資總額 - 扣除總額 - 貸款還款
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +39,Current BOM and New BOM can not be same,當前BOM和新BOM不能相同
-apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +47,Salary Slip ID,工資單編號
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +135,Date Of Retirement must be greater than Date of Joining,日期退休必須大於加入的日期
-apps/erpnext/erpnext/stock/doctype/item/item.js +70,Multiple Variants,多種變體
-DocType: Sales Invoice,Against Income Account,對收入科目
-DocType: Subscription,Trial Period Start Date,試用期開始日期
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +106,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,項目{0}：有序數量{1}不能低於最低訂貨量{2}（項中定義）。
-DocType: Certification Application,Certified,認證
-DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,每月分配比例
-DocType: Daily Work Summary Group User,Daily Work Summary Group User,日常工作摘要組用戶
-DocType: Territory,Territory Targets,境內目標
-DocType: Soil Analysis,Ca/Mg,鈣/鎂
-DocType: Delivery Note,Transporter Info,貨運公司資訊
-apps/erpnext/erpnext/accounts/utils.py +526,Please set default {0} in Company {1},請設置在默認情況下公司{0} {1}
-DocType: Cheque Print Template,Starting position from top edge,起價頂邊位置
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +33,Same supplier has been entered multiple times,同一個供應商已多次輸入
-apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,總利潤/虧損
-,Warehouse wise Item Balance Age and Value,倉庫明智的項目平衡年齡和價值
-DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,採購訂單項目供應商
-apps/erpnext/erpnext/public/js/setup_wizard.js +94,Company Name cannot be Company,公司名稱不能為公司
-apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,信頭的列印模板。
-apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,"列印模板的標題, 例如 Proforma Invoice。"
-DocType: Student Guardian,Student Guardian,學生家長
-DocType: Member,Member Name,成員名字
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +231,Valuation type charges can not marked as Inclusive,估值類型罪名不能標記為包容性
-DocType: POS Profile,Update Stock,庫存更新
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100,Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,不同計量單位的項目會導致不正確的（總）淨重值。確保每個項目的淨重是在同一個計量單位。
-DocType: Certification Application,Payment Details,付款詳情
-apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +41,BOM Rate,BOM率
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +249,"Stopped Work Order cannot be cancelled, Unstop it first to cancel",停止的工作訂單不能取消，先取消它
-DocType: Asset,Journal Entry for Scrap,日記帳分錄報廢
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83,Please pull items from Delivery Note,請送貨單拉項目
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +242,Row {0}: select the workstation against the operation {1},行{0}：根據操作{1}選擇工作站
-apps/erpnext/erpnext/accounts/utils.py +496,Journal Entries {0} are un-linked,日記條目{0}都是非聯
-apps/erpnext/erpnext/accounts/utils.py +825,{0} Number {1} already used in account {2},已在{2}科目中使用的{0}號碼{1}
-apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.",類型電子郵件，電話，聊天，訪問等所有通信記錄
-DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,供應商記分卡
-DocType: Manufacturer,Manufacturers used in Items,在項目中使用製造商
-apps/erpnext/erpnext/accounts/general_ledger.py +181,Please mention Round Off Cost Center in Company,請提及公司舍入成本中心
-DocType: Purchase Invoice,Terms,條款
-apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +10,Select Days,選擇天數
-DocType: Academic Term,Term Name,術語名稱
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +503,Creating Salary Slips...,創建工資單......
-apps/erpnext/erpnext/hr/doctype/department/department.js +14,You cannot edit root node.,您不能編輯根節點。
-DocType: Buying Settings,Purchase Order Required,採購訂單為必要項
-apps/erpnext/erpnext/public/js/projects/timer.js +5,Timer,計時器
-,Item-wise Sales History,項目明智的銷售歷史
-DocType: Expense Claim,Total Sanctioned Amount,總被制裁金額
-,Purchase Analytics,採購分析
-DocType: Sales Invoice Item,Delivery Note Item,送貨單項目
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +373,Current invoice {0} is missing,當前發票{0}缺失
-DocType: Asset Maintenance Log,Task,任務
-DocType: Purchase Taxes and Charges,Reference Row #,參考列#
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76,Batch number is mandatory for Item {0},批號是強制性的項目{0}
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +22,This is a root sales person and cannot be edited.,您可以通過選擇備份頻率啟動和\
-DocType: Salary Component,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ",如果選擇此項，則在此組件中指定或計算的值不會對收入或扣除貢獻。但是，它的值可以被添加或扣除的其他組件引用。
-DocType: Salary Component,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ",如果選擇此項，則在此組件中指定或計算的值不會對收入或扣除貢獻。但是，它的值可以被添加或扣除的其他組件引用。
-DocType: Asset Settings,Number of Days in Fiscal Year,會計年度的天數
-,Stock Ledger,庫存總帳
-apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},價格：{0}
-DocType: Company,Exchange Gain / Loss Account,匯兌損益科目
-DocType: Amazon MWS Settings,MWS Credentials,MWS憑證
-apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,員工考勤
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +123,Purpose must be one of {0},目的必須是一個{0}
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +99,Fill the form and save it,填寫表格，並將其保存
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,社區論壇
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52,Actual qty in stock,實際庫存數量
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52,Actual qty in stock,實際庫存數量
-DocType: Homepage,"URL for ""All Products""",網址“所有產品”
-DocType: Leave Application,Leave Balance Before Application,離開平衡應用前
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +41,Send SMS,發送短信
-DocType: Supplier Scorecard Criteria,Max Score,最高分數
-DocType: Cheque Print Template,Width of amount in word,在字量的寬度
-DocType: Company,Default Letter Head,預設信頭
-DocType: Purchase Order,Get Items from Open Material Requests,從開放狀態的物料需求取得項目
-DocType: Hotel Room Amenity,Billable,計費
-DocType: Lab Test Template,Standard Selling Rate,標準銷售率
-DocType: Account,Rate at which this tax is applied,此稅適用的匯率
-DocType: Cash Flow Mapper,Section Name,部分名稱
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +92,Reorder Qty,再訂購數量
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +292,Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},折舊行{0}：使用壽命後的預期值必須大於或等於{1}
-apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +55,Current Job Openings,當前職位空缺
-DocType: Company,Stock Adjustment Account,庫存調整科目
-apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,註銷項款
-DocType: Healthcare Service Unit,Allow Overlap,允許重疊
-DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.",系統用戶（登錄）的標識。如果設定，這將成為的所有人力資源的預設形式。
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +86,Enter depreciation details,輸入折舊明細
-apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}：從{1}
-apps/erpnext/erpnext/education/doctype/student_leave_application/student_leave_application.py +31,Leave application {0} already exists against the student {1},對學生{1}已經存在申請{0}
-DocType: Task,depends_on,depends_on
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +78,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,排隊更新所有材料清單中的最新價格。可能需要幾分鐘。
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,新帳戶的名稱。注：請不要創建帳戶的客戶和供應商
-DocType: POS Profile,Display Items In Stock,顯示庫存商品
-apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,依據國家別啟發式的預設地址模板
-DocType: Payment Order,Payment Order Reference,付款訂單參考
-DocType: Water Analysis,Appearance,出現
-DocType: HR Settings,Leave Status Notification Template,離開狀態通知模板
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +77,Avg. Buying Price List Rate,平均。買價格表價格
-DocType: Sales Order Item,Supplier delivers to Customer,供應商提供給客戶
-apps/erpnext/erpnext/config/non_profit.py +23,Member information.,會員信息。
-DocType: Identification Document Type,Identification Document Type,識別文件類型
-apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}]（＃窗體/項目/ {0}）缺貨
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +87,Asset Maintenance,資產維護
-,Sales Payment Summary,銷售付款摘要
-DocType: Restaurant,Restaurant,餐廳
-DocType: Woocommerce Settings,API consumer key,API消費者密鑰
-apps/erpnext/erpnext/accounts/party.py +353,Due / Reference Date cannot be after {0},由於/參考日期不能後{0}
-apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,資料輸入和輸出
-DocType: Tax Withholding Category,Account Details,帳戶細節
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76,No students Found,沒有發現學生
-DocType: Clinical Procedure,Medical Department,醫學系
-DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,供應商記分卡評分標準
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55,Invoice Posting Date,發票發布日期
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,賣
-DocType: Purchase Invoice,Rounded Total,整數總計
-apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +91,Slots for {0} are not added to the schedule,{0}的插槽未添加到計劃中
-DocType: Product Bundle,List items that form the package.,形成包列表項。
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +42,Not permitted. Please disable the Test Template,不允許。請禁用測試模板
-DocType: Delivery Note,Distance (in km),距離（公里）
-apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,百分比分配總和應該等於100%
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +611,Please select Posting Date before selecting Party,在選擇之前，甲方請選擇發布日期
-DocType: Program Enrollment,School House,學校議院
-DocType: Serial No,Out of AMC,出資產管理公司
-DocType: Opportunity,Opportunity Amount,機會金額
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +212,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,預訂折舊數不能超過折舊總數更大
-DocType: Purchase Order,Order Confirmation Date,訂單確認日期
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,使維護訪問
-DocType: Employee Transfer,Employee Transfer Details,員工轉移詳情
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +263,Please contact to the user who have Sales Master Manager {0} role,請聯絡，誰擁有碩士學位的銷售經理{0}角色的用戶
-DocType: Company,Default Cash Account,預設的現金科目
-apps/erpnext/erpnext/config/accounts.py +40,Company (not Customer or Supplier) master.,公司（不是客戶或供應商）的主人。
-apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,這是基於這名學生出席
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +179,No Students in,沒有學生
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +180,Add more items or open full form,添加更多項目或全開放形式
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +224,Delivery Notes {0} must be cancelled before cancelling this Sales Order,送貨單{0}必須先取消才能取消銷貨訂單
-apps/erpnext/erpnext/utilities/user_progress.py +259,Go to Users,轉到用戶
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +113,Paid amount + Write Off Amount can not be greater than Grand Total,支付的金額+寫的抵銷金額不能大於總計
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,{0} is not a valid Batch Number for Item {1},{0}不是對項目的有效批號{1}
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +198,Note: There is not enough leave balance for Leave Type {0},注：沒有足夠的休假餘額請假類型{0}
-apps/erpnext/erpnext/regional/india/utils.py +19,Invalid GSTIN or Enter NA for Unregistered,無效的GSTIN或輸入NA未註冊
-DocType: Training Event,Seminar,研討會
-DocType: Program Enrollment Fee,Program Enrollment Fee,計劃註冊費
-DocType: Item,Supplier Items,供應商項目
-DocType: Opportunity,Opportunity Type,機會型
-DocType: Asset Movement,To Employee,給員工
-DocType: Employee Transfer,New Company,新公司
-apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +19,Transactions can only be deleted by the creator of the Company,交易只能由公司的創建者被刪除
-apps/erpnext/erpnext/accounts/general_ledger.py +21,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,不正確的數字總帳條目中找到。你可能會在交易中選擇了錯誤的科目。
-DocType: Employee,Prefered Contact Email,首選聯繫郵箱
-DocType: Cheque Print Template,Cheque Width,支票寬度
-DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,驗證售價反對預訂價或估價RATE項目
-DocType: Fee Schedule,Fee Schedule,收費表
-DocType: Company,Create Chart Of Accounts Based On,基於會計科目表創建
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +129,Date of Birth cannot be greater than today.,出生日期不能大於今天。
-,Stock Ageing,存貨帳齡分析表
-DocType: Travel Request,"Partially Sponsored, Require Partial Funding",部分贊助，需要部分資金
-apps/erpnext/erpnext/education/doctype/student/student.py +40,Student {0} exist against student applicant {1},學生{0}存在針對學生申請{1}
-DocType: Purchase Invoice,Rounding Adjustment (Company Currency),四捨五入調整（公司貨幣）
-apps/erpnext/erpnext/projects/doctype/task/task.js +39,Timesheet,時間表
-apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +243,Batch: ,批量：
-DocType: Loyalty Program,Loyalty Program Help,忠誠度計劃幫助
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,設置為打開
-DocType: Cheque Print Template,Scanned Cheque,支票掃描
-DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,對提交的交易，自動發送電子郵件給聯絡人。
-DocType: Timesheet,Total Billable Amount,總結算金額
-DocType: Customer,Credit Limit and Payment Terms,信用額度和付款條款
-DocType: Loyalty Program,Collection Rules,收集規則
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,項目3
-apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6,Order Entry,訂單輸入
-DocType: Purchase Order,Customer Contact Email,客戶聯絡電子郵件
-DocType: Warranty Claim,Item and Warranty Details,項目和保修細節
-DocType: Chapter,Chapter Members,章節成員
-DocType: Sales Team,Contribution (%),貢獻（％）
-apps/erpnext/erpnext/controllers/accounts_controller.py +143,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,注：付款項將不會被創建因為“現金或銀行科目”未指定
-apps/erpnext/erpnext/projects/doctype/project/project.py +79,Project {0} already exists,項目{0}已經存在
-DocType: Clinical Procedure,Nursing User,護理用戶
-DocType: Employee Benefit Application,Payroll Period,工資期
-DocType: Plant Analysis,Plant Analysis Criterias,植物分析標準
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +239,Serial No {0} does not belong to Batch {1},序列號{0}不屬於批次{1}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197,Responsibilities,職責
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125,Validity period of this quotation has ended.,此報價的有效期已經結束。
-DocType: Expense Claim Account,Expense Claim Account,報銷科目
-DocType: Account,Capital Work in Progress,資本工作正在進行中
-DocType: Accounts Settings,Allow Stale Exchange Rates,允許陳舊的匯率
-DocType: Sales Person,Sales Person Name,銷售人員的姓名
-apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,請在表中輸入至少一筆發票
-apps/erpnext/erpnext/utilities/user_progress.py +247,Add Users,添加用戶
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py +74,No Lab Test created,沒有創建實驗室測試
-DocType: POS Item Group,Item Group,項目群組
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +19,Student Group: ,學生組：
-DocType: Depreciation Schedule,Finance Book Id,金融書籍ID
-DocType: Item,Safety Stock,安全庫存
-DocType: Healthcare Settings,Healthcare Settings,醫療設置
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +8,Total Allocated Leaves,總分配的葉子
-apps/erpnext/erpnext/projects/doctype/task/task.py +57,Progress % for a task cannot be more than 100.,為任務進度百分比不能超過100個。
-DocType: Stock Reconciliation Item,Before reconciliation,調整前
-DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),稅收和收費上架（公司貨幣）
-apps/erpnext/erpnext/stock/doctype/item/item.py +507,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,商品稅行{0}必須有科目類型為"稅" 或 "收入" 或 "支出" 或 "課稅的"
-DocType: Sales Order,Partly Billed,天色帳單
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +54,Item {0} must be a Fixed Asset Item,項{0}必須是固定資產項目
-apps/erpnext/erpnext/stock/doctype/item/item.js +427,Make Variants,變種
-DocType: Item,Default BOM,預設的BOM
-DocType: Project,Total Billed Amount (via Sales Invoices),總開票金額（通過銷售發票）
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +138,Debit Note Amount,借方票據金額
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +107,"There are inconsistencies between the rate, no of shares and the amount calculated",費率，股份數量和計算的金額之間不一致
-apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +39,You are not present all day(s) between compensatory leave request days,您在補休請求日之間不是全天
-apps/erpnext/erpnext/setup/doctype/company/company.js +109,Please re-type company name to confirm,請確認重新輸入公司名稱
-apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +50,Total Outstanding Amt,總街貨量金額
-DocType: Journal Entry,Printing Settings,列印設定
-DocType: Employee Advance,Advance Account,預付款科目
-DocType: Job Offer,Job Offer Terms,招聘條款
-DocType: Sales Invoice,Include Payment (POS),包括支付（POS）
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +324,Total Debit must be equal to Total Credit. The difference is {0},借方總額必須等於貸方總額。差額為{0}
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11,Automotive,汽車
-DocType: Vehicle,Insurance Company,保險公司
-DocType: Asset Category Account,Fixed Asset Account,固定資產科目
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +442,Variable,變量
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,從送貨單
-DocType: Chapter,Members,會員
-DocType: Student,Student Email Address,學生的電子郵件地址
-DocType: Item,Hub Warehouse,Hub倉庫
-DocType: Cashier Closing,From Time,從時間
-DocType: Hotel Settings,Hotel Settings,酒店設置
-apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock: ,有現貨：
-DocType: Notification Control,Custom Message,自定義訊息
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33,Investment Banking,投資銀行業務
-DocType: Purchase Invoice,input,輸入
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +107,Cash or Bank Account is mandatory for making payment entry,製作付款分錄時，現金或銀行科目是強制性輸入的欄位。
-DocType: Loyalty Program,Multiple Tier Program,多層計劃
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,學生地址
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,學生地址
-DocType: Purchase Invoice,Price List Exchange Rate,價目表匯率
-apps/erpnext/erpnext/patches/v11_0/rename_supplier_type_to_supplier_group.py +27,All Supplier Groups,所有供應商組織
-DocType: Employee Boarding Activity,Required for Employee Creation,員工創建需要
-apps/erpnext/erpnext/accounts/doctype/account/account.py +214,Account Number {0} already used in account {1},已在科目{1}中使用的帳號{0}
-DocType: Hotel Room Reservation,Booked,預訂
-DocType: Detected Disease,Tasks Created,創建的任務
-DocType: Purchase Invoice Item,Rate,單價
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +82,Intern,實習生
-DocType: Delivery Stop,Address Name,地址名稱
-DocType: Stock Entry,From BOM,從BOM
-DocType: Assessment Code,Assessment Code,評估準則
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +51,Basic,基本的
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,{0}前的庫存交易被凍結
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219,Please click on 'Generate Schedule',請點擊“生成表”
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +154,Reference No is mandatory if you entered Reference Date,如果你輸入的參考日期，參考編號是強制性的
-DocType: Bank Reconciliation Detail,Payment Document,付款單據
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37,Error evaluating the criteria formula,評估標準公式時出錯
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +132,Date of Joining must be greater than Date of Birth,加入日期必須大於出生日期
-DocType: Subscription,Plans,計劃
-DocType: Salary Slip,Salary Structure,薪酬結構
-DocType: Account,Bank,銀行
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +886,Issue Material,發行材料
-apps/erpnext/erpnext/config/integrations.py +32,Connect Shopify with ERPNext,將Shopify與ERPNext連接
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1161,For Warehouse,對於倉庫
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +92,Delivery Notes {0} updated,已更新交貨單{0}
-DocType: Employee,Offer Date,到職日期
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +35,Quotations,語錄
-apps/erpnext/erpnext/accounts/page/pos/pos.js +742,You are in offline mode. You will not be able to reload until you have network.,您在離線模式。您將無法重新加載，直到你有網絡。
-apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js +90,Grant,格蘭特
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,沒有學生團體創建的。
-DocType: Purchase Invoice Item,Serial No,序列號
-apps/erpnext/erpnext/hr/doctype/loan/loan.py +129,Monthly Repayment Amount cannot be greater than Loan Amount,每月還款額不能超過貸款金額較大
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143,Please enter Maintaince Details first,請先輸入維護細節
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +60,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,行＃{0}：預計交貨日期不能在採購訂單日期之前
-DocType: Purchase Invoice,Print Language,打印語言
-DocType: Salary Slip,Total Working Hours,總的工作時間
-DocType: Sales Invoice,Customer PO Details,客戶PO詳細信息
-DocType: Stock Entry,Including items for sub assemblies,包括子組件項目
-DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,臨時開戶
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1979,Enter value must be positive,輸入值必須為正
-DocType: Asset,Finance Books,財務書籍
-DocType: Employee Tax Exemption Declaration Category,Employee Tax Exemption Declaration Category,員工免稅申報類別
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +451,All Territories,所有的領土
-apps/erpnext/erpnext/hr/utils.py +216,Please set leave policy for employee {0} in Employee / Grade record,請在員工/成績記錄中為員工{0}設置休假政策
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1472,Invalid Blanket Order for the selected Customer and Item,所選客戶和物料的無效總訂單
-apps/erpnext/erpnext/projects/doctype/task/task_tree.js +49,Add Multiple Tasks,添加多個任務
-DocType: Purchase Invoice,Items,項目
-apps/erpnext/erpnext/crm/doctype/contract/contract.py +38,End Date cannot be before Start Date.,結束日期不能在開始日期之前。
-apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +33,Student is already enrolled.,學生已經註冊。
-DocType: Fiscal Year,Year Name,年結名稱
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +323,There are more holidays than working days this month.,還有比這個月工作日更多的假期。
-apps/erpnext/erpnext/controllers/buying_controller.py +772,Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,以下項{0}未標記為{1}項。您可以從項目主文件中將它們作為{1}項啟用
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +117,PDC/LC Ref,PDC / LC參考
-DocType: Production Plan Item,Product Bundle Item,產品包項目
-DocType: Sales Partner,Sales Partner Name,銷售合作夥伴名稱
-apps/erpnext/erpnext/hooks.py +148,Request for Quotations,索取報價
-DocType: Payment Reconciliation,Maximum Invoice Amount,最大發票額
-DocType: Normal Test Items,Normal Test Items,正常測試項目
-DocType: QuickBooks Migrator,Company Settings,公司設置
-DocType: Additional Salary,Overwrite Salary Structure Amount,覆蓋薪資結構金額
-DocType: Student Language,Student Language,學生語言
-apps/erpnext/erpnext/config/selling.py +23,Customers,顧客
-DocType: Cash Flow Mapping,Is Working Capital,是營運資本
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,訂單/報價％
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,訂單/報價％
-apps/erpnext/erpnext/config/healthcare.py +25,Record Patient Vitals,記錄患者維生素
-DocType: Fee Schedule,Institution,機構
-DocType: Asset,Partially Depreciated,部分貶抑
-DocType: Issue,Opening Time,開放時間
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +97,From and To dates required,需要起始和到達日期
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46,Securities & Commodity Exchanges,證券及商品交易所
-apps/erpnext/erpnext/stock/doctype/item/item.py +760,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',測度變異的默認單位“{0}”必須是相同模板“{1}”
-DocType: Shipping Rule,Calculate Based On,計算的基礎上
-DocType: Contract,Unfulfilled,秕
-DocType: Delivery Note Item,From Warehouse,從倉庫
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +68,No employees for the mentioned criteria,沒有僱員提到的標準
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1033,No Items with Bill of Materials to Manufacture,不與物料清單的項目，以製造
-DocType: Shopify Settings,Default Customer,默認客戶
-DocType: Sales Stage,Stage Name,藝名
-DocType: Assessment Plan,Supervisor Name,主管名稱
-DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,不要確認是否在同一天創建約會
-DocType: Program Enrollment Course,Program Enrollment Course,課程註冊課程
-DocType: Program Enrollment Course,Program Enrollment Course,課程註冊課程
-apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner.py +59,User {0} is already assigned to Healthcare Practitioner {1},用戶{0}已分配給Healthcare Practitioner {1}
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +187,Make Sample Retention Stock Entry,使樣品保留庫存條目
-DocType: Purchase Taxes and Charges,Valuation and Total,估值與總計
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +226,Negotiation/Review,談判/評論
-DocType: Leave Encashment,Encashment Amount,填充量
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11,Scorecards,記分卡
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +159,Expired Batches,過期批次
-DocType: Employee,This will restrict user access to other employee records,這將限制用戶訪問其他員工記錄
-DocType: Tax Rule,Shipping City,航運市
-DocType: Staffing Plan Detail,Current Openings,當前空缺
-DocType: Notification Control,Customize the Notification,自定義通知
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +78,Cash Flow from Operations,運營現金流
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +316,CGST Amount,CGST金額
-DocType: Purchase Invoice,Shipping Rule,送貨規則
-DocType: Patient Relation,Spouse,伴侶
-DocType: Lab Test Groups,Add Test,添加測試
-DocType: Manufacturer,Limited to 12 characters,限12個字符
-DocType: Journal Entry,Print Heading,列印標題
-apps/erpnext/erpnext/config/stock.py +149,Delivery Trip service tours to customers.,送貨服務遊覽給顧客。
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57,Total cannot be zero,總計不能為零
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,“自從最後訂購日”必須大於或等於零
-DocType: Plant Analysis Criteria,Maximum Permissible Value,最大允許值
-DocType: Journal Entry Account,Employee Advance,員工晉升
-DocType: Payroll Entry,Payroll Frequency,工資頻率
-DocType: Lab Test Template,Sensitivity,靈敏度
-apps/erpnext/erpnext/erpnext_integrations/doctype/amazon_mws_settings/amazon_methods.py +132,Sync has been temporarily disabled because maximum retries have been exceeded,暫時禁用了同步，因為已超出最大重試次數
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1015,Raw Material,原料
-DocType: Leave Application,Follow via Email,透過電子郵件追蹤
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +56,Plants and Machineries,廠房和機械設備
-DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,稅額折後金額
-DocType: Patient,Inpatient Status,住院狀況
-DocType: Daily Work Summary Settings,Daily Work Summary Settings,每日工作總結設置
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1298,Selected Price List should have buying and selling fields checked.,選定價目表應該有買入和賣出的字段。
-apps/erpnext/erpnext/controllers/buying_controller.py +693,Please enter Reqd by Date,請輸入按日期請求
-DocType: Payment Entry,Internal Transfer,內部轉賬
-DocType: Asset Maintenance,Maintenance Tasks,維護任務
-apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,無論是數量目標或目標量是必需的
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +627,Please select Posting Date first,請選擇發布日期第一
-apps/erpnext/erpnext/public/js/account_tree_grid.js +209,Opening Date should be before Closing Date,開業日期應該是截止日期之前，
-DocType: Travel Itinerary,Flight,飛行
-DocType: Leave Control Panel,Carry Forward,發揚
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +32,Cost Center with existing transactions can not be converted to ledger,與現有的交易成本中心，不能轉換為總賬
-DocType: Budget,Applicable on booking actual expenses,適用於預訂實際費用
-DocType: Department,Days for which Holidays are blocked for this department.,天的假期被封鎖這個部門。
-DocType: Crop Cycle,Detected Disease,檢測到的疾病
-,Produced,生產
-apps/erpnext/erpnext/hr/doctype/loan/loan.py +26,Repayment Start Date cannot be before Disbursement Date.,還款開始日期不能在付款日期之前。
-DocType: Item,Item Code for Suppliers,對於供應商產品編號
-DocType: Issue,Raised By (Email),由（電子郵件）提出
-DocType: Training Event,Trainer Name,培訓師姓名
-DocType: Mode of Payment,General,一般
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,最後溝通
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,最後溝通
-,TDS Payable Monthly,TDS應付月度
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +73,Queued for replacing the BOM. It may take a few minutes.,排隊等待更換BOM。可能需要幾分鐘時間。
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +385,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',不能抵扣當類別為“估值”或“估值及總'
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +286,Serial Nos Required for Serialized Item {0},序列號為必填項序列為{0}
-apps/erpnext/erpnext/config/accounts.py +140,Match Payments with Invoices,付款與發票對照
-DocType: Journal Entry,Bank Entry,銀行分錄
-DocType: Authorization Rule,Applicable To (Designation),適用於（指定）
-DocType: Fees,Student Email,學生電子郵件
-DocType: Patient,"Allergies, Medical and Surgical History",過敏，醫療和外科史
-apps/erpnext/erpnext/templates/generators/item.html +96,Add to Cart,添加到購物車
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +197,Group By,集團通過
-DocType: Guardian,Interests,興趣
-apps/erpnext/erpnext/config/accounts.py +266,Enable / disable currencies.,啟用／禁用的貨幣。
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +553,Could not submit some Salary Slips,無法提交一些薪資單
-DocType: Exchange Rate Revaluation,Get Entries,獲取條目
-DocType: Production Plan,Get Material Request,獲取材質要求
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,Postal Expenses,郵政費用
-apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html +8,Sales Summary,銷售摘要
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26,Entertainment & Leisure,娛樂休閒
-,Item Variant Details,項目變體的詳細信息
-DocType: Quality Inspection,Item Serial No,產品序列號
-DocType: Payment Request,Is a Subscription,是訂閱
-apps/erpnext/erpnext/utilities/activation.py +135,Create Employee Records,建立員工檔案
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +97,Total Present,總現
-apps/erpnext/erpnext/config/accounts.py +83,Accounting Statements,會計報表
-DocType: Drug Prescription,Hour,小時
-DocType: Restaurant Order Entry,Last Sales Invoice,上次銷售發票
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +881,Please select Qty against item {0},請選擇項目{0}的數量
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +33,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,新的序列號不能有倉庫。倉庫必須由存貨分錄或採購入庫單進行設定
-DocType: Lead,Lead Type,主導類型
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +183,You are not authorized to approve leaves on Block Dates,在限制的日期，您無權批准休假
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +408,All these items have already been invoiced,所有這些項目已開具發票
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +1024,Set New Release Date,設置新的發布日期
-DocType: Company,Monthly Sales Target,每月銷售目標
-apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},可以通過{0}的批准
-DocType: Hotel Room,Hotel Room Type,酒店房間類型
-DocType: Leave Allocation,Leave Period,休假期間
-DocType: Item,Default Material Request Type,默認材料請求類型
-DocType: Supplier Scorecard,Evaluation Period,評估期
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1032,Work Order not created,工作訂單未創建
-apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +36,"An amount of {0} already claimed for the component {1},\
+Row #{0}: Duplicate entry in References {1} {2},行＃{0}：引用{1} {2}中的重複條目
+Where manufacturing operations are carried.,生產作業於此進行。
+As Examiner,作為考官
+Default Expense Claim Payable Account,默認費用索賠應付帳款
+Default Duration,默認時長
+Source Warehouse,來源倉庫
+Installation Date,安裝日期
+Row #{0}: Asset {1} does not belong to company {2},行＃{0}：資產{1}不屬於公司{2}
+Sales Invoice {0} created,已創建銷售發票{0}
+Confirmation Date,確認日期
+Check Out,查看
+Total Invoiced Amount,發票總金額
+Min Qty can not be greater than Max Qty,最小數量不能大於最大數量
+Accumulated Depreciation,累計折舊
+Standing Name,常務名稱
+Customer or Supplier Details,客戶或供應商詳細訊息
+Current Asset Value,流動資產價值
+Travel Funding,旅行資助
+A link to all the Locations in which the Crop is growing,指向作物生長的所有位置的鏈接
+Lead Owner,主導擁有者
+Sales Orders Detail,銷售訂單明細
+Requested Quantity,要求的數量
+EDU-FEE-.YYYY.-,EDU-收費.YYYY.-
+Marital Status,婚姻狀況
+Auto Material Request,自動物料需求
+API consumer secret,API消費者秘密
+Available Batch Qty at From Warehouse,在從倉庫可用的批次數量
+Gross Pay - Total Deduction - Loan Repayment,工資總額 - 扣除總額 - 貸款還款
+Current BOM and New BOM can not be same,當前BOM和新BOM不能相同
+Salary Slip ID,工資單編號
+Date Of Retirement must be greater than Date of Joining,日期退休必須大於加入的日期
+Multiple Variants,多種變體
+Against Income Account,對收入科目
+Trial Period Start Date,試用期開始日期
+Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,項目{0}：有序數量{1}不能低於最低訂貨量{2}（項中定義）。
+Certified,認證
+Monthly Distribution Percentage,每月分配比例
+Daily Work Summary Group User,日常工作摘要組用戶
+Territory Targets,境內目標
+Ca/Mg,鈣/鎂
+Transporter Info,貨運公司資訊
+Please set default {0} in Company {1},請設置在默認情況下公司{0} {1}
+Starting position from top edge,起價頂邊位置
+Same supplier has been entered multiple times,同一個供應商已多次輸入
+Gross Profit / Loss,總利潤/虧損
+Warehouse wise Item Balance Age and Value,倉庫明智的項目平衡年齡和價值
+Purchase Order Item Supplied,採購訂單項目供應商
+Company Name cannot be Company,公司名稱不能為公司
+Letter Heads for print templates.,信頭的列印模板。
+Titles for print templates e.g. Proforma Invoice.,"列印模板的標題, 例如 Proforma Invoice。"
+Student Guardian,學生家長
+Member Name,成員名字
+Valuation type charges can not marked as Inclusive,估值類型罪名不能標記為包容性
+Update Stock,庫存更新
+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.,不同計量單位的項目會導致不正確的（總）淨重值。確保每個項目的淨重是在同一個計量單位。
+Payment Details,付款詳情
+BOM Rate,BOM率
+"Stopped Work Order cannot be cancelled, Unstop it first to cancel",停止的工作訂單不能取消，先取消它
+Journal Entry for Scrap,日記帳分錄報廢
+Please pull items from Delivery Note,請送貨單拉項目
+Row {0}: select the workstation against the operation {1},行{0}：根據操作{1}選擇工作站
+Journal Entries {0} are un-linked,日記條目{0}都是非聯
+{0} Number {1} already used in account {2},已在{2}科目中使用的{0}號碼{1}
+"Record of all communications of type email, phone, chat, visit, etc.",類型電子郵件，電話，聊天，訪問等所有通信記錄
+Supplier Scorecard Scoring Standing,供應商記分卡
+Manufacturers used in Items,在項目中使用製造商
+Please mention Round Off Cost Center in Company,請提及公司舍入成本中心
+Terms,條款
+Select Days,選擇天數
+Term Name,術語名稱
+Creating Salary Slips...,創建工資單......
+You cannot edit root node.,您不能編輯根節點。
+Purchase Order Required,採購訂單為必要項
+Timer,計時器
+Item-wise Sales History,項目明智的銷售歷史
+Total Sanctioned Amount,總被制裁金額
+Purchase Analytics,採購分析
+Delivery Note Item,送貨單項目
+Current invoice {0} is missing,當前發票{0}缺失
+Task,任務
+Reference Row #,參考列#
+Batch number is mandatory for Item {0},批號是強制性的項目{0}
+This is a root sales person and cannot be edited.,您可以通過選擇備份頻率啟動和\
+"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ",如果選擇此項，則在此組件中指定或計算的值不會對收入或扣除貢獻。但是，它的值可以被添加或扣除的其他組件引用。
+"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ",如果選擇此項，則在此組件中指定或計算的值不會對收入或扣除貢獻。但是，它的值可以被添加或扣除的其他組件引用。
+Number of Days in Fiscal Year,會計年度的天數
+Stock Ledger,庫存總帳
+Rate: {0},價格：{0}
+Exchange Gain / Loss Account,匯兌損益科目
+MWS Credentials,MWS憑證
+Employee and Attendance,員工考勤
+Purpose must be one of {0},目的必須是一個{0}
+Fill the form and save it,填寫表格，並將其保存
+Community Forum,社區論壇
+Actual qty in stock,實際庫存數量
+Actual qty in stock,實際庫存數量
+"URL for ""All Products""",網址“所有產品”
+Leave Balance Before Application,離開平衡應用前
+Send SMS,發送短信
+Max Score,最高分數
+Width of amount in word,在字量的寬度
+Default Letter Head,預設信頭
+Get Items from Open Material Requests,從開放狀態的物料需求取得項目
+Billable,計費
+Standard Selling Rate,標準銷售率
+Rate at which this tax is applied,此稅適用的匯率
+Section Name,部分名稱
+Reorder Qty,再訂購數量
+Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},折舊行{0}：使用壽命後的預期值必須大於或等於{1}
+Current Job Openings,當前職位空缺
+Stock Adjustment Account,庫存調整科目
+Write Off,註銷項款
+Allow Overlap,允許重疊
+"System User (login) ID. If set, it will become default for all HR forms.",系統用戶（登錄）的標識。如果設定，這將成為的所有人力資源的預設形式。
+Enter depreciation details,輸入折舊明細
+{0}: From {1},{0}：從{1}
+Leave application {0} already exists against the student {1},對學生{1}已經存在申請{0}
+depends_on,depends_on,
+Queued for updating latest price in all Bill of Materials. It may take a few minutes.,排隊更新所有材料清單中的最新價格。可能需要幾分鐘。
+Name of new Account. Note: Please don't create accounts for Customers and Suppliers,新帳戶的名稱。注：請不要創建帳戶的客戶和供應商
+Display Items In Stock,顯示庫存商品
+Country wise default Address Templates,依據國家別啟發式的預設地址模板
+Payment Order Reference,付款訂單參考
+Appearance,出現
+Leave Status Notification Template,離開狀態通知模板
+Avg. Buying Price List Rate,平均。買價格表價格
+Supplier delivers to Customer,供應商提供給客戶
+Member information.,會員信息。
+Identification Document Type,識別文件類型
+[{0}](#Form/Item/{0}) is out of stock,[{0}]（＃窗體/項目/ {0}）缺貨
+Asset Maintenance,資產維護
+Sales Payment Summary,銷售付款摘要
+Restaurant,餐廳
+API consumer key,API消費者密鑰
+Due / Reference Date cannot be after {0},由於/參考日期不能後{0}
+Data Import and Export,資料輸入和輸出
+Account Details,帳戶細節
+No students Found,沒有發現學生
+Medical Department,醫學系
+Supplier Scorecard Scoring Criteria,供應商記分卡評分標準
+Invoice Posting Date,發票發布日期
+Sell,賣
+Rounded Total,整數總計
+Slots for {0} are not added to the schedule,{0}的插槽未添加到計劃中
+List items that form the package.,形成包列表項。
+Not permitted. Please disable the Test Template,不允許。請禁用測試模板
+Distance (in km),距離（公里）
+Percentage Allocation should be equal to 100%,百分比分配總和應該等於100%
+Please select Posting Date before selecting Party,在選擇之前，甲方請選擇發布日期
+School House,學校議院
+Out of AMC,出資產管理公司
+Opportunity Amount,機會金額
+Number of Depreciations Booked cannot be greater than Total Number of Depreciations,預訂折舊數不能超過折舊總數更大
+Order Confirmation Date,訂單確認日期
+Make Maintenance Visit,使維護訪問
+Employee Transfer Details,員工轉移詳情
+Please contact to the user who have Sales Master Manager {0} role,請聯絡，誰擁有碩士學位的銷售經理{0}角色的用戶
+Default Cash Account,預設的現金科目
+Company (not Customer or Supplier) master.,公司（不是客戶或供應商）的主人。
+This is based on the attendance of this Student,這是基於這名學生出席
+No Students in,沒有學生
+Add more items or open full form,添加更多項目或全開放形式
+Delivery Notes {0} must be cancelled before cancelling this Sales Order,送貨單{0}必須先取消才能取消銷貨訂單
+Go to Users,轉到用戶
+Paid amount + Write Off Amount can not be greater than Grand Total,支付的金額+寫的抵銷金額不能大於總計
+{0} is not a valid Batch Number for Item {1},{0}不是對項目的有效批號{1}
+Note: There is not enough leave balance for Leave Type {0},注：沒有足夠的休假餘額請假類型{0}
+Invalid GSTIN or Enter NA for Unregistered,無效的GSTIN或輸入NA未註冊
+Seminar,研討會
+Program Enrollment Fee,計劃註冊費
+Supplier Items,供應商項目
+Opportunity Type,機會型
+To Employee,給員工
+New Company,新公司
+Transactions can only be deleted by the creator of the Company,交易只能由公司的創建者被刪除
+Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,不正確的數字總帳條目中找到。你可能會在交易中選擇了錯誤的科目。
+Prefered Contact Email,首選聯繫郵箱
+Cheque Width,支票寬度
+Validate Selling Price for Item against Purchase Rate or Valuation Rate,驗證售價反對預訂價或估價RATE項目
+Fee Schedule,收費表
+Create Chart Of Accounts Based On,基於會計科目表創建
+Date of Birth cannot be greater than today.,出生日期不能大於今天。
+Stock Ageing,存貨帳齡分析表
+"Partially Sponsored, Require Partial Funding",部分贊助，需要部分資金
+Student {0} exist against student applicant {1},學生{0}存在針對學生申請{1}
+Rounding Adjustment (Company Currency),四捨五入調整（公司貨幣）
+Timesheet,時間表
+Batch: ,批量：
+Loyalty Program Help,忠誠度計劃幫助
+Set as Open,設置為打開
+Scanned Cheque,支票掃描
+Send automatic emails to Contacts on Submitting transactions.,對提交的交易，自動發送電子郵件給聯絡人。
+Total Billable Amount,總結算金額
+Credit Limit and Payment Terms,信用額度和付款條款
+Collection Rules,收集規則
+Item 3,項目3,
+Order Entry,訂單輸入
+Customer Contact Email,客戶聯絡電子郵件
+Item and Warranty Details,項目和保修細節
+Chapter Members,章節成員
+Contribution (%),貢獻（％）
+Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,注：付款項將不會被創建因為“現金或銀行科目”未指定
+Project {0} already exists,項目{0}已經存在
+Nursing User,護理用戶
+Payroll Period,工資期
+Plant Analysis Criterias,植物分析標準
+Serial No {0} does not belong to Batch {1},序列號{0}不屬於批次{1}
+Responsibilities,職責
+Validity period of this quotation has ended.,此報價的有效期已經結束。
+Expense Claim Account,報銷科目
+Capital Work in Progress,資本工作正在進行中
+Allow Stale Exchange Rates,允許陳舊的匯率
+Sales Person Name,銷售人員的姓名
+Please enter atleast 1 invoice in the table,請在表中輸入至少一筆發票
+Add Users,添加用戶
+No Lab Test created,沒有創建實驗室測試
+Item Group,項目群組
+Student Group: ,學生組：
+Finance Book Id,金融書籍ID,
+Safety Stock,安全庫存
+Healthcare Settings,醫療設置
+Total Allocated Leaves,總分配的葉子
+Progress % for a task cannot be more than 100.,為任務進度百分比不能超過100個。
+Before reconciliation,調整前
+Taxes and Charges Added (Company Currency),稅收和收費上架（公司貨幣）
+Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,商品稅行{0}必須有科目類型為"稅" 或 "收入" 或 "支出" 或 "課稅的"
+Partly Billed,天色帳單
+Item {0} must be a Fixed Asset Item,項{0}必須是固定資產項目
+Make Variants,變種
+Default BOM,預設的BOM,
+Total Billed Amount (via Sales Invoices),總開票金額（通過銷售發票）
+Debit Note Amount,借方票據金額
+"There are inconsistencies between the rate, no of shares and the amount calculated",費率，股份數量和計算的金額之間不一致
+You are not present all day(s) between compensatory leave request days,您在補休請求日之間不是全天
+Please re-type company name to confirm,請確認重新輸入公司名稱
+Total Outstanding Amt,總街貨量金額
+Printing Settings,列印設定
+Advance Account,預付款科目
+Job Offer Terms,招聘條款
+Include Payment (POS),包括支付（POS）
+Total Debit must be equal to Total Credit. The difference is {0},借方總額必須等於貸方總額。差額為{0}
+Automotive,汽車
+Insurance Company,保險公司
+Fixed Asset Account,固定資產科目
+Variable,變量
+From Delivery Note,從送貨單
+Members,會員
+Student Email Address,學生的電子郵件地址
+Hub Warehouse,Hub倉庫
+From Time,從時間
+Hotel Settings,酒店設置
+In Stock: ,有現貨：
+Custom Message,自定義訊息
+Investment Banking,投資銀行業務
+input,輸入
+Cash or Bank Account is mandatory for making payment entry,製作付款分錄時，現金或銀行科目是強制性輸入的欄位。
+Multiple Tier Program,多層計劃
+Student Address,學生地址
+Student Address,學生地址
+Price List Exchange Rate,價目表匯率
+All Supplier Groups,所有供應商組織
+Required for Employee Creation,員工創建需要
+Account Number {0} already used in account {1},已在科目{1}中使用的帳號{0}
+Booked,預訂
+Tasks Created,創建的任務
+Rate,單價
+Intern,實習生
+Address Name,地址名稱
+From BOM,從BOM,
+Assessment Code,評估準則
+Basic,基本的
+Stock transactions before {0} are frozen,{0}前的庫存交易被凍結
+Please click on 'Generate Schedule',請點擊“生成表”
+Reference No is mandatory if you entered Reference Date,如果你輸入的參考日期，參考編號是強制性的
+Payment Document,付款單據
+Error evaluating the criteria formula,評估標準公式時出錯
+Date of Joining must be greater than Date of Birth,加入日期必須大於出生日期
+Plans,計劃
+Salary Structure,薪酬結構
+Bank,銀行
+Issue Material,發行材料
+Connect Shopify with ERPNext,將Shopify與ERPNext連接
+For Warehouse,對於倉庫
+Delivery Notes {0} updated,已更新交貨單{0}
+Offer Date,到職日期
+Quotations,語錄
+You are in offline mode. You will not be able to reload until you have network.,您在離線模式。您將無法重新加載，直到你有網絡。
+Grant,格蘭特
+No Student Groups created.,沒有學生團體創建的。
+Serial No,序列號
+Monthly Repayment Amount cannot be greater than Loan Amount,每月還款額不能超過貸款金額較大
+Please enter Maintaince Details first,請先輸入維護細節
+Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,行＃{0}：預計交貨日期不能在採購訂單日期之前
+Print Language,打印語言
+Total Working Hours,總的工作時間
+Customer PO Details,客戶PO詳細信息
+Including items for sub assemblies,包括子組件項目
+Temporary Opening Account,臨時開戶
+Enter value must be positive,輸入值必須為正
+Finance Books,財務書籍
+Employee Tax Exemption Declaration Category,員工免稅申報類別
+All Territories,所有的領土
+Please set leave policy for employee {0} in Employee / Grade record,請在員工/成績記錄中為員工{0}設置休假政策
+Invalid Blanket Order for the selected Customer and Item,所選客戶和物料的無效總訂單
+Add Multiple Tasks,添加多個任務
+Items,項目
+End Date cannot be before Start Date.,結束日期不能在開始日期之前。
+Student is already enrolled.,學生已經註冊。
+Year Name,年結名稱
+There are more holidays than working days this month.,還有比這個月工作日更多的假期。
+Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,以下項{0}未標記為{1}項。您可以從項目主文件中將它們作為{1}項啟用
+PDC/LC Ref,PDC / LC參考
+Product Bundle Item,產品包項目
+Sales Partner Name,銷售合作夥伴名稱
+Request for Quotations,索取報價
+Maximum Invoice Amount,最大發票額
+Normal Test Items,正常測試項目
+Company Settings,公司設置
+Overwrite Salary Structure Amount,覆蓋薪資結構金額
+Student Language,學生語言
+Customers,顧客
+Is Working Capital,是營運資本
+Order/Quot %,訂單/報價％
+Order/Quot %,訂單/報價％
+Record Patient Vitals,記錄患者維生素
+Institution,機構
+Partially Depreciated,部分貶抑
+Opening Time,開放時間
+From and To dates required,需要起始和到達日期
+Securities & Commodity Exchanges,證券及商品交易所
+Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',測度變異的默認單位“{0}”必須是相同模板“{1}”
+Calculate Based On,計算的基礎上
+Unfulfilled,秕
+From Warehouse,從倉庫
+No employees for the mentioned criteria,沒有僱員提到的標準
+No Items with Bill of Materials to Manufacture,不與物料清單的項目，以製造
+Default Customer,默認客戶
+Stage Name,藝名
+Supervisor Name,主管名稱
+Do not confirm if appointment is created for the same day,不要確認是否在同一天創建約會
+Program Enrollment Course,課程註冊課程
+Program Enrollment Course,課程註冊課程
+User {0} is already assigned to Healthcare Practitioner {1},用戶{0}已分配給Healthcare Practitioner {1}
+Make Sample Retention Stock Entry,使樣品保留庫存條目
+Valuation and Total,估值與總計
+Negotiation/Review,談判/評論
+Encashment Amount,填充量
+Scorecards,記分卡
+Expired Batches,過期批次
+This will restrict user access to other employee records,這將限制用戶訪問其他員工記錄
+Shipping City,航運市
+Current Openings,當前空缺
+Customize the Notification,自定義通知
+Cash Flow from Operations,運營現金流
+CGST Amount,CGST金額
+Shipping Rule,送貨規則
+Spouse,伴侶
+Add Test,添加測試
+Limited to 12 characters,限12個字符
+Print Heading,列印標題
+Delivery Trip service tours to customers.,送貨服務遊覽給顧客。
+Total cannot be zero,總計不能為零
+'Days Since Last Order' must be greater than or equal to zero,“自從最後訂購日”必須大於或等於零
+Maximum Permissible Value,最大允許值
+Employee Advance,員工晉升
+Payroll Frequency,工資頻率
+Sensitivity,靈敏度
+Sync has been temporarily disabled because maximum retries have been exceeded,暫時禁用了同步，因為已超出最大重試次數
+Raw Material,原料
+Follow via Email,透過電子郵件追蹤
+Plants and Machineries,廠房和機械設備
+Tax Amount After Discount Amount,稅額折後金額
+Inpatient Status,住院狀況
+Daily Work Summary Settings,每日工作總結設置
+Selected Price List should have buying and selling fields checked.,選定價目表應該有買入和賣出的字段。
+Please enter Reqd by Date,請輸入按日期請求
+Internal Transfer,內部轉賬
+Maintenance Tasks,維護任務
+Either target qty or target amount is mandatory,無論是數量目標或目標量是必需的
+Please select Posting Date first,請選擇發布日期第一
+Opening Date should be before Closing Date,開業日期應該是截止日期之前，
+Flight,飛行
+Carry Forward,發揚
+Cost Center with existing transactions can not be converted to ledger,與現有的交易成本中心，不能轉換為總賬
+Applicable on booking actual expenses,適用於預訂實際費用
+Days for which Holidays are blocked for this department.,天的假期被封鎖這個部門。
+Detected Disease,檢測到的疾病
+Produced,生產
+Repayment Start Date cannot be before Disbursement Date.,還款開始日期不能在付款日期之前。
+Item Code for Suppliers,對於供應商產品編號
+Raised By (Email),由（電子郵件）提出
+Trainer Name,培訓師姓名
+General,一般
+Last Communication,最後溝通
+Last Communication,最後溝通
+TDS Payable Monthly,TDS應付月度
+Queued for replacing the BOM. It may take a few minutes.,排隊等待更換BOM。可能需要幾分鐘時間。
+Cannot deduct when category is for 'Valuation' or 'Valuation and Total',不能抵扣當類別為“估值”或“估值及總'
+Serial Nos Required for Serialized Item {0},序列號為必填項序列為{0}
+Match Payments with Invoices,付款與發票對照
+Bank Entry,銀行分錄
+Applicable To (Designation),適用於（指定）
+Student Email,學生電子郵件
+"Allergies, Medical and Surgical History",過敏，醫療和外科史
+Add to Cart,添加到購物車
+Group By,集團通過
+Interests,興趣
+Enable / disable currencies.,啟用／禁用的貨幣。
+Could not submit some Salary Slips,無法提交一些薪資單
+Get Entries,獲取條目
+Get Material Request,獲取材質要求
+Postal Expenses,郵政費用
+Sales Summary,銷售摘要
+Entertainment & Leisure,娛樂休閒
+Item Variant Details,項目變體的詳細信息
+Item Serial No,產品序列號
+Is a Subscription,是訂閱
+Create Employee Records,建立員工檔案
+Total Present,總現
+Accounting Statements,會計報表
+Hour,小時
+Last Sales Invoice,上次銷售發票
+Please select Qty against item {0},請選擇項目{0}的數量
+New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,新的序列號不能有倉庫。倉庫必須由存貨分錄或採購入庫單進行設定
+Lead Type,主導類型
+You are not authorized to approve leaves on Block Dates,在限制的日期，您無權批准休假
+All these items have already been invoiced,所有這些項目已開具發票
+Set New Release Date,設置新的發布日期
+Monthly Sales Target,每月銷售目標
+Can be approved by {0},可以通過{0}的批准
+Hotel Room Type,酒店房間類型
+Leave Period,休假期間
+Default Material Request Type,默認材料請求類型
+Evaluation Period,評估期
+Work Order not created,工作訂單未創建
+"An amount of {0} already claimed for the component {1},\
 						 set the amount equal or greater than {2}",已為組件{1}申請的金額{0}，設置等於或大於{2}的金額
-DocType: Shipping Rule,Shipping Rule Conditions,送貨規則條件
-DocType: Purchase Invoice,Export Type,導出類型
-DocType: Salary Slip Loan,Salary Slip Loan,工資單貸款
-DocType: BOM Update Tool,The new BOM after replacement,更換後的新物料清單
-,Point of Sale,銷售點
-DocType: Payment Entry,Received Amount,收金額
-DocType: Patient,Widow,寡婦
-DocType: GST Settings,GSTIN Email Sent On,發送GSTIN電子郵件
-DocType: Program Enrollment,Pick/Drop by Guardian,由守護者選擇
-DocType: Bank Account,SWIFT number,SWIFT號碼
-DocType: Payment Entry,Party Name,方名稱
-DocType: Employee Benefit Application,Benefits Applied,應用的好處
-DocType: Crop,Planting UOM,種植UOM
-DocType: Account,Tax,稅
-apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,未標記
-DocType: Contract,Signed,簽
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1,Opening Invoices Summary,打開發票摘要
-DocType: Education Settings,Education Manager,教育經理
-DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,每個工廠之間的最小長度為最佳的增長
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +153,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry",批量項目{0}無法使用庫存調節更新，而是使用庫存條目
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +153,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry",批量項目{0}無法使用庫存調節更新，而是使用庫存條目
-DocType: Quality Inspection,Report Date,報告日期
-DocType: Student,Middle Name,中間名字
-DocType: Serial No,Asset Details,資產詳情
-DocType: Bank Statement Transaction Payment Item,Invoices,發票
-DocType: Water Analysis,Type of Sample,樣品類型
-DocType: Batch,Source Document Name,源文檔名稱
-DocType: Production Plan,Get Raw Materials For Production,獲取生產原料
-DocType: Job Opening,Job Title,職位
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +89,"{0} indicates that {1} will not provide a quotation, but all items \
+Shipping Rule Conditions,送貨規則條件
+Export Type,導出類型
+Salary Slip Loan,工資單貸款
+The new BOM after replacement,更換後的新物料清單
+Point of Sale,銷售點
+Received Amount,收金額
+Widow,寡婦
+GSTIN Email Sent On,發送GSTIN電子郵件
+Pick/Drop by Guardian,由守護者選擇
+SWIFT number,SWIFT號碼
+Party Name,方名稱
+Benefits Applied,應用的好處
+Planting UOM,種植UOM,
+Tax,稅
+Not Marked,未標記
+Signed,簽
+Opening Invoices Summary,打開發票摘要
+Education Manager,教育經理
+The minimum length between each plant in the field for optimum growth,每個工廠之間的最小長度為最佳的增長
+"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry",批量項目{0}無法使用庫存調節更新，而是使用庫存條目
+"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry",批量項目{0}無法使用庫存調節更新，而是使用庫存條目
+Report Date,報告日期
+Middle Name,中間名字
+Asset Details,資產詳情
+Invoices,發票
+Type of Sample,樣品類型
+Source Document Name,源文檔名稱
+Get Raw Materials For Production,獲取生產原料
+Job Title,職位
+"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.",{0}表示{1}不會提供報價，但所有項目都已被引用。更新詢價狀態。
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1294,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,批次{1}和批次{3}中的項目{2}已保留最大樣本數量{0}。
-DocType: Manufacturing Settings,Update BOM Cost Automatically,自動更新BOM成本
-DocType: Lab Test,Test Name,測試名稱
-DocType: Healthcare Settings,Clinical Procedure Consumable Item,臨床程序消耗品
-apps/erpnext/erpnext/utilities/activation.py +99,Create Users,創建用戶
-apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +30,Subscriptions,訂閱
-DocType: Education Settings,Make Academic Term Mandatory,強制學術期限
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +414,Quantity to Manufacture must be greater than 0.,量生產必須大於0。
-DocType: Asset Settings,Calculate Prorated Depreciation Schedule Based on Fiscal Year,根據會計年度計算折舊折舊計劃
-apps/erpnext/erpnext/config/maintenance.py +17,Visit report for maintenance call.,訪問報告維修電話。
-DocType: Stock Entry,Update Rate and Availability,更新率和可用性
-DocType: Stock Settings,Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.,相對於訂單量允許接受或交付的變動百分比額度。例如：如果你下定100個單位量，而你的許可額度是10%，那麼你可以收到最多110個單位量。
-DocType: Loyalty Program,Customer Group,客戶群組
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +300,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order # {3}. Please update operation status via Time Logs,行＃{0}：操作{1}未完成{2}工件訂單＃{3}中成品的數量。請通過時間日誌更新操作狀態
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +128,New Batch ID (Optional),新批號（可選）
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +128,New Batch ID (Optional),新批號（可選）
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +231,Expense account is mandatory for item {0},交際費是強制性的項目{0}
-DocType: BOM,Website Description,網站簡介
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +101,Net Change in Equity,在淨資產收益變化
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +300,Please cancel Purchase Invoice {0} first,請取消採購發票{0}第一
-apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py +25,Not permitted. Please disable the Service Unit Type,不允許。請禁用服務單位類型
-apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"Email Address must be unique, already exists for {0}",電子郵件地址必須是唯一的，已經存在了{0}
-DocType: Serial No,AMC Expiry Date,AMC到期時間
-DocType: Asset,Receipt,收據
-,Sales Register,銷售登記
-DocType: Daily Work Summary Group,Send Emails At,發送電子郵件在
-DocType: Quotation,Quotation Lost Reason,報價遺失原因
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +383,Transaction reference no {0} dated {1},交易參考編號{0}日{1}
-apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js +5,There is nothing to edit.,無內容可供編輯
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +542,Form View,表單視圖
-DocType: HR Settings,Expense Approver Mandatory In Expense Claim,費用審批人必須在費用索賠中
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +124,Summary for this month and pending activities,本月和待活動總結
-apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py +91,Please set Unrealized Exchange Gain/Loss Account in Company {0},請在公司{0}中設置未實現的匯兌收益/損失科目
-apps/erpnext/erpnext/utilities/user_progress.py +248,"Add users to your organization, other than yourself.",將用戶添加到您的組織，而不是您自己。
-DocType: Customer Group,Customer Group Name,客戶群組名稱
-apps/erpnext/erpnext/public/js/pos/pos.html +109,No Customers yet!,還沒有客戶！
-DocType: Healthcare Service Unit,Healthcare Service Unit,醫療服務單位
-apps/erpnext/erpnext/public/js/financial_statements.js +58,Cash Flow Statement,現金流量表
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +374,No material request created,沒有創建重要請求
-apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23,Loan Amount cannot exceed Maximum Loan Amount of {0},貸款額不能超過最高貸款額度{0}
-apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22,License,執照
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +563,Please remove this Invoice {0} from C-Form {1},請刪除此發票{0}從C-表格{1}
-DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,請選擇結轉，如果你還需要包括上一會計年度的資產負債葉本財年
-DocType: GL Entry,Against Voucher Type,對憑證類型
-DocType: Healthcare Practitioner,Phone (R),電話（R）
-apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +104,Time slots added,添加時隙
-DocType: Item,Attributes,屬性
-apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js +36,Enable Template,啟用模板
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +256,Please enter Write Off Account,請輸入核銷科目
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,最後訂購日期
-DocType: Salary Component,Is Payable,應付
-DocType: Inpatient Record,B Negative,B負面
-apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25,Maintenance Status has to be Cancelled or Completed to Submit,維護狀態必須取消或完成提交
-DocType: Amazon MWS Settings,US,我們
-DocType: Holiday List,Add Weekly Holidays,添加每週假期
-DocType: Staffing Plan Detail,Vacancies,職位空缺
-DocType: Hotel Room,Hotel Room,旅館房間
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +57,Account {0} does not belongs to company {1},科目{0}不屬於公司{1}
-DocType: Leave Type,Rounding,四捨五入
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +994,Serial Numbers in row {0} does not match with Delivery Note,行{0}中的序列號與交貨單不匹配
-DocType: Employee Benefit Application,Dispensed Amount (Pro-rated),分配金額（按比例分配）
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Group, Campaign, Sales Partner etc.",然後根據客戶，客戶組，地區，供應商，供應商組織，市場活動，銷售合作夥伴等篩選定價規則。
-DocType: Student,Guardian Details,衛詳細
-DocType: Agriculture Task,Start Day,開始日
-DocType: Vehicle,Chassis No,底盤無
-DocType: Payment Request,Initiated,啟動
-DocType: Production Plan Item,Planned Start Date,計劃開始日期
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +649,Please select a BOM,請選擇一個物料清單
-DocType: Purchase Invoice,Availed ITC Integrated Tax,有效的ITC綜合稅收
-DocType: Purchase Order Item,Blanket Order Rate,一攬子訂單費率
-apps/erpnext/erpnext/hooks.py +164,Certification,證明
-DocType: Bank Guarantee,Clauses and Conditions,條款和條件
-DocType: Serial No,Creation Document Type,創建文件類型
-DocType: Project Task,View Timesheet,查看時間表
-apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js +24,Make Journal Entry,使日記帳分錄
-DocType: Leave Allocation,New Leaves Allocated,新的排假
-apps/erpnext/erpnext/controllers/trends.py +269,Project-wise data is not available for Quotation,項目明智的數據不適用於報價
-apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30,End on,結束
-DocType: Project,Expected End Date,預計結束日期
-DocType: Budget Account,Budget Amount,預算額
-DocType: Donor,Donor Name,捐助者名稱
-DocType: Journal Entry,Inter Company Journal Entry Reference,Inter公司日記帳分錄參考
-DocType: Appraisal Template,Appraisal Template Title,評估模板標題
-apps/erpnext/erpnext/utilities/user_progress_utils.py +29,Commercial,商業
-DocType: Patient,Alcohol Current Use,酒精當前使用
-DocType: Employee Tax Exemption Proof Submission,House Rent Payment Amount,房屋租金付款金額
-DocType: Student Admission Program,Student Admission Program,學生入學計劃
-DocType: Employee Tax Exemption Sub Category,Tax Exemption Category,免稅類別
-DocType: Payment Entry,Account Paid To,科目付至
-DocType: Subscription Settings,Grace Period,寬限期
-DocType: Item Alternative,Alternative Item Name,替代項目名稱
-apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24,Parent Item {0} must not be a Stock Item,父項{0}不能是庫存產品
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +164,Website Listing,網站列表
-apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,所有的產品或服務。
-DocType: Email Digest,Open Quotations,打開報價單
-DocType: Expense Claim,More Details,更多詳情
-DocType: Supplier Quotation,Supplier Address,供應商地址
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +168,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0}預算科目{1}對{2} {3}是{4}。這將超過{5}
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,輸出數量
-apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +49,Series is mandatory,系列是強制性的
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28,Financial Services,金融服務
-DocType: Student Sibling,Student ID,學生卡
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +214,For Quantity must be greater than zero,對於數量必須大於零
-apps/erpnext/erpnext/config/projects.py +51,Types of activities for Time Logs,活動類型的時間記錄
-DocType: Opening Invoice Creation Tool,Sales,銷售
-DocType: Stock Entry Detail,Basic Amount,基本金額
-DocType: Training Event,Exam,考試
-apps/erpnext/erpnext/public/js/hub/hub_call.js +46,Marketplace Error,市場錯誤
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +534,Warehouse required for stock Item {0},倉庫需要現貨產品{0}
-apps/erpnext/erpnext/hr/doctype/loan/loan.js +83,Make Repayment Entry,進行還款分錄
-apps/erpnext/erpnext/patches/v11_0/update_department_lft_rgt.py +10,All Departments,所有部門
-DocType: Patient,Alcohol Past Use,酒精過去使用
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +248,Cr,鉻
-DocType: Project Update,Problematic/Stuck,問題/卡住
-DocType: Tax Rule,Billing State,計費狀態
-DocType: Share Transfer,Transfer,轉讓
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +268,Work Order {0} must be cancelled before cancelling this Sales Order,在取消此銷售訂單之前，必須先取消工單{0}
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +1008,Fetch exploded BOM (including sub-assemblies),取得爆炸BOM（包括子組件）
-DocType: Authorization Rule,Applicable To (Employee),適用於（員工）
-apps/erpnext/erpnext/controllers/accounts_controller.py +180,Due Date is mandatory,截止日期是強制性的
-apps/erpnext/erpnext/controllers/item_variant.py +82,Increment for Attribute {0} cannot be 0,增量屬性{0}不能為0
-DocType: Employee Benefit Claim,Benefit Type and Amount,福利類型和金額
-apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19,Rooms Booked,客房預訂
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +57,Ends On date cannot be before Next Contact Date.,結束日期不能在下一次聯繫日期之前。
-DocType: Journal Entry,Pay To / Recd From,支付/ 接收
-DocType: Naming Series,Setup Series,設置系列
-DocType: Payment Reconciliation,To Invoice Date,要發票日期
-DocType: Bank Account,Contact HTML,聯繫HTML
-DocType: Support Settings,Support Portal,支持門戶
-apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19,Registration fee can not be Zero,註冊費不能為零
-DocType: Disease,Treatment Period,治療期
-DocType: Travel Itinerary,Travel Itinerary,旅遊行程
-apps/erpnext/erpnext/education/api.py +336,Result already Submitted,結果已提交
-apps/erpnext/erpnext/controllers/buying_controller.py +209,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,保留倉庫對於提供的原材料中的項目{0}是強制性的
-,Inactive Customers,不活躍的客戶
-DocType: Student Admission Program,Maximum Age,最大年齡
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28,Please wait 3 days before resending the reminder.,請重新發送提醒之前請等待3天。
-DocType: Landed Cost Voucher,Purchase Receipts,採購入庫
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29,How Pricing Rule is applied?,定價規則被如何應用？
-DocType: Stock Entry,Delivery Note No,送貨單號
-DocType: Cheque Print Template,Message to show,信息顯示
-DocType: Student Attendance,Absent,缺席
-DocType: Staffing Plan,Staffing Plan Detail,人員配置計劃詳情
-DocType: Employee Promotion,Promotion Date,促銷日期
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +622,Product Bundle,產品包
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38,Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,無法從{0}開始獲得分數。你需要有0到100的常規分數
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244,Row {0}: Invalid reference {1},行{0}：無效參考{1}
-DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,採購稅負和費用模板
-DocType: Subscription,Current Invoice Start Date,當前發票開始日期
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61,{0} {1}: Either debit or credit amount is required for {2},{0} {1}：無論是借方或貸方金額需要{2}
-DocType: GL Entry,Remarks,備註
-DocType: Hotel Room Amenity,Hotel Room Amenity,酒店客房舒適
-DocType: Budget,Action if Annual Budget Exceeded on MR,年度預算超出MR的行動
-DocType: Payment Entry,Account Paid From,帳戶支付從
-DocType: Purchase Order Item Supplied,Raw Material Item Code,原料產品編號
-DocType: Task,Parent Task,父任務
-DocType: Journal Entry,Write Off Based On,核銷的基礎上
-apps/erpnext/erpnext/utilities/activation.py +65,Make Lead,使鉛
-DocType: Stock Settings,Show Barcode Field,顯示條形碼域
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +866,Send Supplier Emails,發送電子郵件供應商
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +165,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.",工資已經處理了與{0}和{1}，留下申請期之間不能在此日期範圍內的時期。
-DocType: Fiscal Year,Auto Created,自動創建
-apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py +19,Submit this to create the Employee record,提交這個來創建員工記錄
-DocType: Item Default,Item Default,項目默認值
-DocType: Chapter Member,Leave Reason,離開原因
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +197,Invoice {0} no longer exists,發票{0}不再存在
-DocType: Guardian Interest,Guardian Interest,衛利息
-apps/erpnext/erpnext/config/accounts.py +544,Setup default values for POS Invoices,設置POS發票的默認值
-apps/erpnext/erpnext/config/hr.py +248,Training,訓練
-DocType: Project,Time to send,發送時間
-DocType: Timesheet,Employee Detail,員工詳細信息
-apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.py +19,Set warehouse for Procedure {0} ,為過程{0}設置倉庫
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1電子郵件ID
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1電子郵件ID
-DocType: Lab Prescription,Test Code,測試代碼
-apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,對網站的主頁設置
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +895,{0} is on hold till {1},{0}一直保持到{1}
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +40,RFQs are not allowed for {0} due to a scorecard standing of {1},由於{1}的記分卡，{0}不允許使用RFQ
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +9,Used Leaves,使用的葉子
-DocType: Job Offer,Awaiting Response,正在等待回應
-DocType: Support Search Source,Link Options,鏈接選項
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1557,Total Amount {0},總金額{0}
-apps/erpnext/erpnext/controllers/item_variant.py +323,Invalid attribute {0} {1},無效的屬性{0} {1}
-DocType: Supplier,Mention if non-standard payable account,如果非標準應付帳款提到
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +25,Please select the assessment group other than 'All Assessment Groups',請選擇“所有評估組”以外的評估組
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67,Row {0}: Cost center is required for an item {1},行{0}：項目{1}需要費用中心
-DocType: Training Event Employee,Optional,可選的
-apps/erpnext/erpnext/stock/doctype/item/item.js +476,{0} variants created.,創建了{0}個變體。
-DocType: Amazon MWS Settings,Region,區域
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +36,Optional. This setting will be used to filter in various transactions.,可選。此設置將被應用於過濾各種交易進行。
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +111,Negative Valuation Rate is not allowed,負面評價率是不允許的
-DocType: Holiday List,Weekly Off,每週關閉
-apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7,Reload Linked Analysis,重新加載鏈接分析
-DocType: Fiscal Year,"For e.g. 2012, 2012-13",對於例如2012、2012-13
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +99,Provisional Profit / Loss (Credit),臨時溢利/（虧損）（信用）
-DocType: Sales Invoice,Return Against Sales Invoice,射向銷售發票
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32,Item 5,項目5
-DocType: Serial No,Creation Time,創作時間
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62,Total Revenue,總收入
-DocType: Patient,Other Risk Factors,其他風險因素
-DocType: Sales Invoice,Product Bundle Help,產品包幫助
-apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py +15,No record found,沒有資料
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +155,Cost of Scrapped Asset,報廢資產成本
-apps/erpnext/erpnext/controllers/stock_controller.py +240,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}：成本中心是強制性的項目{2}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +743,Get Items from Product Bundle,從產品包取得項目
-DocType: Asset,Straight Line,直線
-DocType: Project User,Project User,項目用戶
-DocType: Employee Transfer,Re-allocate Leaves,重新分配葉子
-DocType: GL Entry,Is Advance,為進
-apps/erpnext/erpnext/config/hr.py +202,Employee Lifecycle,員工生命週期
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,考勤起始日期和出席的日期，是強制性的
-apps/erpnext/erpnext/controllers/buying_controller.py +196,Please enter 'Is Subcontracted' as Yes or No,請輸入'轉包' YES或NO
-DocType: Item,Default Purchase Unit of Measure,默認採購單位
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,最後通訊日期
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,最後通訊日期
-DocType: Clinical Procedure Item,Clinical Procedure Item,臨床流程項目
-DocType: Sales Team,Contact No.,聯絡電話
-DocType: Bank Reconciliation,Payment Entries,付款項
-apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py +33,Access token or Shopify URL missing,訪問令牌或Shopify網址丟失
-DocType: Location,Latitude,緯度
-DocType: Work Order,Scrap Warehouse,廢料倉庫
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +192,"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}",在第{0}行，需要倉庫，請為公司{2}的物料{1}設置默認倉庫
-DocType: Work Order,Check if material transfer entry is not required,檢查是否不需要材料轉移條目
-DocType: Work Order,Check if material transfer entry is not required,檢查是否不需要材料轉移條目
-DocType: Program Enrollment Tool,Get Students From,讓學生從
-apps/erpnext/erpnext/config/learn.py +263,Publish Items on Website,公佈於網頁上的項目
-apps/erpnext/erpnext/utilities/activation.py +126,Group your students in batches,一群學生在分批
-DocType: Authorization Rule,Authorization Rule,授權規則
-DocType: Sales Invoice,Terms and Conditions Details,條款及細則詳情
-apps/erpnext/erpnext/templates/generators/item.html +118,Specifications,產品規格
-DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,營業稅金及費用套版
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +70,Total (Credit),總（信用）
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10,Apparel & Accessories,服裝及配飾
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91,Could not solve weighted score function. Make sure the formula is valid.,無法解決加權分數函數。確保公式有效。
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +186,Purchase Order Items not received on time,未按時收到採購訂單項目
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,訂購數量
-DocType: Item Group,HTML / Banner that will show on the top of product list.,HTML／橫幅，將顯示在產品列表的頂部。
-DocType: Shipping Rule,Specify conditions to calculate shipping amount,指定條件來計算運費金額
-DocType: Program Enrollment,Institute's Bus,學院的巴士
-DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,允許設定凍結科目和編輯凍結分錄的角色
-DocType: Supplier Scorecard Scoring Variable,Path,路徑
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cannot convert Cost Center to ledger as it has child nodes,不能成本中心轉換為總賬，因為它有子節點
-DocType: Production Plan,Total Planned Qty,總計劃數量
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +83,Opening Value,開度值
-DocType: Salary Component,Formula,式
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +59,Serial #,序列號
-DocType: Lab Test Template,Lab Test Template,實驗室測試模板
-apps/erpnext/erpnext/setup/doctype/company/company.py +196,Sales Account,銷售科目
-DocType: Purchase Invoice Item,Total Weight,總重量
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +101,Commission on Sales,銷售佣金
-DocType: Job Offer Term,Value / Description,值/說明
-apps/erpnext/erpnext/controllers/accounts_controller.py +706,"Row #{0}: Asset {1} cannot be submitted, it is already {2}",行＃{0}：資產{1}無法提交，這已經是{2}
-DocType: Tax Rule,Billing Country,結算國家
-DocType: Purchase Order Item,Expected Delivery Date,預計交貨日期
-DocType: Restaurant Order Entry,Restaurant Order Entry,餐廳訂單錄入
-apps/erpnext/erpnext/accounts/general_ledger.py +134,Debit and Credit not equal for {0} #{1}. Difference is {2}.,借貸{0}＃不等於{1}。區別是{2}。
-DocType: Clinical Procedure Item,Invoice Separately as Consumables,作為耗材單獨發票
-DocType: Budget,Control Action,控制行動
-DocType: Asset Maintenance Task,Assign To Name,分配到名稱
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +105,Entertainment Expenses,娛樂費用
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +98,Make Material Request,製作材料要求
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},打開項目{0}
-DocType: Asset Finance Book,Written Down Value,寫下價值
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +235,Sales Invoice {0} must be cancelled before cancelling this Sales Order,銷售發票{0}必須早於此銷售訂單之前取消
-DocType: Clinical Procedure,Age,年齡
-DocType: Sales Invoice Timesheet,Billing Amount,開票金額
-DocType: Cash Flow Mapping,Select Maximum Of 1,選擇最多1個
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,為項目指定了無效的數量{0} 。量應大於0 。
-DocType: Company,Default Employee Advance Account,默認員工高級帳戶
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1181,Search Item (Ctrl + i),搜索項目（Ctrl + i）
-apps/erpnext/erpnext/accounts/doctype/account/account.py +171,Account with existing transaction can not be deleted,科目與現有的交易不能被刪除
-DocType: Vehicle,Last Carbon Check,最後檢查炭
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Legal Expenses,法律費用
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +147,Please select quantity on row ,請選擇行數量
-apps/erpnext/erpnext/config/accounts.py +245,Make Opening Sales and Purchase Invoices,打開銷售和購買發票
-DocType: Purchase Invoice,Posting Time,登錄時間
-DocType: Timesheet,% Amount Billed,（％）金額已開立帳單
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +125,Telephone Expenses,電話費
-DocType: Sales Partner,Logo,標誌
-DocType: Naming Series,Check this if you want to force the user to select a series before saving. There will be no default if you check this.,如果要強制用戶在儲存之前選擇了一系列，則勾選此項。如果您勾選此項，則將沒有預設值。
-apps/erpnext/erpnext/stock/get_item_details.py +150,No Item with Serial No {0},沒有序號{0}的品項
-DocType: Email Digest,Open Notifications,打開通知
-DocType: Payment Entry,Difference Amount (Company Currency),差異金額（公司幣種）
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +83,Direct Expenses,直接費用
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,新客戶收入
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +126,Travel Expenses,差旅費
-DocType: Maintenance Visit,Breakdown,展開
-DocType: Travel Itinerary,Vegetarian,素
-apps/erpnext/erpnext/controllers/accounts_controller.py +907,Account: {0} with currency: {1} can not be selected,帳號：{0}幣種：{1}不能選擇
-DocType: Bank Statement Transaction Settings Item,Bank Data,銀行數據
-DocType: Purchase Receipt Item,Sample Quantity,樣品數量
-DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.",根據最新的估值/價格清單率/最近的原材料採購率，通過計劃程序自動更新BOM成本。
-apps/erpnext/erpnext/accounts/doctype/account/account.py +57,Account {0}: Parent account {1} does not belong to company: {2},科目{0}：上層科目{1}不屬於公司：{2}
-apps/erpnext/erpnext/setup/doctype/company/company.js +126,Successfully deleted all transactions related to this company!,成功刪除與該公司相關的所有交易！
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +22,As on Date,隨著對日
-DocType: Program Enrollment,Enrollment Date,報名日期
-DocType: Healthcare Settings,Out Patient SMS Alerts,輸出病人短信
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +78,Probation,緩刑
-DocType: Program Enrollment Tool,New Academic Year,新學年
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +866,Return / Credit Note,返回/信用票據
-DocType: Stock Settings,Auto insert Price List rate if missing,自動插入價目表率，如果丟失
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +137,Total Paid Amount,總支付金額
-DocType: Job Card,Transferred Qty,轉讓數量
-apps/erpnext/erpnext/config/learn.py +11,Navigating,導航
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +141,Planning,規劃
-DocType: Contract,Signee,簽署人
-DocType: Share Balance,Issued,發行
-DocType: Loan,Repayment Start Date,還款開始日期
-apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14,Student Activity,學生活動
-apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80,Supplier Id,供應商編號
-DocType: Payment Request,Payment Gateway Details,支付網關細節
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +290,Quantity should be greater than 0,量應大於0
-DocType: Journal Entry,Cash Entry,現金分錄
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,Child nodes can be only created under 'Group' type nodes,子節點可以在&#39;集團&#39;類型的節點上創建
-DocType: Academic Year,Academic Year Name,學年名稱
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1182,{0} not allowed to transact with {1}. Please change the Company.,不允許{0}與{1}進行交易。請更改公司。
-DocType: Sales Partner,Contact Desc,聯絡倒序
-DocType: Email Digest,Send regular summary reports via Email.,使用電子郵件發送定期匯總報告。
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +289,Please set default account in Expense Claim Type {0},請報銷類型設置默認科目{0}
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +11,Available Leaves,可用的葉子
-DocType: Assessment Result,Student Name,學生姓名
-DocType: Hub Tracked Item,Item Manager,項目經理
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Payroll Payable,應付職工薪酬
-DocType: Plant Analysis,Collection Datetime,收集日期時間
-DocType: Work Order,Total Operating Cost,總營運成本
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +172,Note: Item {0} entered multiple times,注：項目{0}多次輸入
-apps/erpnext/erpnext/config/selling.py +41,All Contacts.,所有聯絡人。
-DocType: Accounting Period,Closed Documents,關閉的文件
-DocType: Healthcare Settings,Manage Appointment Invoice submit and cancel automatically for Patient Encounter,管理約會發票提交並自動取消患者遭遇
-DocType: Patient Appointment,Referring Practitioner,轉介醫生
-apps/erpnext/erpnext/public/js/setup_wizard.js +71,Company Abbreviation,公司縮寫
-apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner.py +51,User {0} does not exist,用戶{0}不存在
-DocType: Payment Term,Day(s) after invoice date,發票日期後的天數
-apps/erpnext/erpnext/setup/doctype/company/company.js +34,Date of Commencement should be greater than Date of Incorporation,開始日期應大於公司註冊日期
-DocType: Contract,Signed On,簽名
-DocType: Bank Account,Party Type,黨的類型
-DocType: Payment Schedule,Payment Schedule,付款時間表
-DocType: Item Attribute Value,Abbreviation,縮寫
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +220,Payment Entry already exists,付款項目已存在
-DocType: Subscription,Trial Period End Date,試用期結束日期
-apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,不允許因為{0}超出範圍
-DocType: Serial No,Asset Status,資產狀態
-DocType: Delivery Note,Over Dimensional Cargo (ODC),超尺寸貨物（ODC）
-DocType: Hotel Room,Hotel Manager,酒店經理
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +64,Set Tax Rule for shopping cart,購物車稅收規則設定
-DocType: Purchase Invoice,Taxes and Charges Added,稅費上架
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +223,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,折舊行{0}：下一個折舊日期不能在可供使用的日期之前
-,Sales Funnel,銷售漏斗
-apps/erpnext/erpnext/setup/doctype/company/company.py +53,Abbreviation is mandatory,縮寫是強制性的
-DocType: Project,Task Progress,任務進度
-apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7,Cart,車
-DocType: Staffing Plan,Total Estimated Budget,預計總預算
-,Qty to Transfer,轉移數量
-apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,行情到引線或客戶。
-DocType: Stock Settings,Role Allowed to edit frozen stock,此角色可以編輯凍結的庫存
-,Territory Target Variance Item Group-Wise,地域內跨項目群組間的目標差異
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +108,All Customer Groups,所有客戶群組
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +155,Accumulated Monthly,每月累計
-apps/erpnext/erpnext/controllers/accounts_controller.py +864,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0}是強制性的。也許外幣兌換記錄為{1}到{2}尚未建立。
-apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py +51,Staffing Plan {0} already exist for designation {1},已存在人員配置計劃{0}以用於指定{1}
-apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +46,Tax Template is mandatory.,稅務模板是強制性的。
-apps/erpnext/erpnext/accounts/doctype/account/account.py +51,Account {0}: Parent account {1} does not exist,科目{0}：上層科目{1}不存在
-DocType: POS Closing Voucher,Period Start Date,期間開始日期
-DocType: Purchase Invoice Item,Price List Rate (Company Currency),價格列表費率（公司貨幣）
-DocType: Products Settings,Products Settings,產品設置
-,Item Price Stock,項目價格庫存
-apps/erpnext/erpnext/config/accounts.py +550,To make Customer based incentive schemes.,制定基於客戶的激勵計劃。
-DocType: Lab Prescription,Test Created,測試創建
-DocType: Healthcare Settings,Custom Signature in Print,自定義簽名打印
-DocType: Account,Temporary,臨時
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +127,Customer LPO No.,客戶LPO號
-DocType: Amazon MWS Settings,Market Place Account Group,市場科目組
-apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js +14,Make Payment Entries,付款條目
-DocType: Program,Courses,培訓班
-DocType: Monthly Distribution Percentage,Percentage Allocation,百分比分配
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +91,Secretary,秘書
-apps/erpnext/erpnext/regional/india/utils.py +177,House rented dates required for exemption calculation,房子租用日期計算免責
-DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction",如果禁用“，在詞”字段不會在任何交易可見
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +29,This action will stop future billing. Are you sure you want to cancel this subscription?,此操作將停止未來的結算。您確定要取消此訂閱嗎？
-DocType: Serial No,Distinct unit of an Item,一個項目的不同的單元
-DocType: Supplier Scorecard Criteria,Criteria Name,標準名稱
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.js +406,Please set Company,請設公司
-DocType: Procedure Prescription,Procedure Created,程序已創建
-DocType: Pricing Rule,Buying,採購
-apps/erpnext/erpnext/config/agriculture.py +24,Diseases & Fertilizers,疾病與肥料
-DocType: HR Settings,Employee Records to be created by,員工紀錄的創造者
-DocType: Inpatient Record,AB Negative,AB陰性
-DocType: POS Profile,Apply Discount On,申請折扣
-DocType: Member,Membership Type,會員類型
-,Reqd By Date,REQD按日期
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +147,Creditors,債權人
-DocType: Assessment Plan,Assessment Name,評估名稱
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +107,Show PDC in Print,在打印中顯示PDC
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +95,Row # {0}: Serial No is mandatory,行＃{0}：序列號是必需的
-DocType: Purchase Taxes and Charges,Item Wise Tax Detail,項目智者稅制明細
-DocType: Employee Onboarding,Job Offer,工作機會
-apps/erpnext/erpnext/public/js/setup_wizard.js +71,Institute Abbreviation,研究所縮寫
-,Item-wise Price List Rate,全部項目的價格表
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1156,Supplier Quotation,供應商報價
-DocType: Quotation,In Words will be visible once you save the Quotation.,報價一被儲存，就會顯示出來。
-apps/erpnext/erpnext/utilities/transaction_base.py +169,Quantity ({0}) cannot be a fraction in row {1},數量（{0}）不能是行{1}中的分數
-apps/erpnext/erpnext/utilities/transaction_base.py +169,Quantity ({0}) cannot be a fraction in row {1},數量（{0}）不能是行{1}中的分數
-DocType: Contract,Unsigned,無符號
-DocType: Selling Settings,Each Transaction,每筆交易
-apps/erpnext/erpnext/stock/doctype/item/item.py +523,Barcode {0} already used in Item {1},條碼{0}已經用在項目{1}
-apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,增加運輸成本的規則。
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +72,Varaiance ,Varaiance
-DocType: Item,Opening Stock,打開庫存
-apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,客戶是必需的
-DocType: Lab Test,Result Date,結果日期
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +129,PDC/LC Date,PDC / LC日期
-DocType: Purchase Order,To Receive,接受
-DocType: Leave Period,Holiday List for Optional Leave,可選假期的假期列表
-DocType: Asset,Asset Owner,資產所有者
-DocType: Purchase Invoice,Reason For Putting On Hold,擱置的理由
-DocType: Employee,Personal Email,個人電子郵件
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +86,Total Variance,總方差
-DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.",如果啟用，系統將自動為發布庫存會計分錄。
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +264,Attendance for employee {0} is already marked for this day,考勤員工{0}已標記為這一天
-DocType: Work Order Operation,"in Minutes
+Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,批次{1}和批次{3}中的項目{2}已保留最大樣本數量{0}。
+Update BOM Cost Automatically,自動更新BOM成本
+Test Name,測試名稱
+Clinical Procedure Consumable Item,臨床程序消耗品
+Create Users,創建用戶
+Subscriptions,訂閱
+Make Academic Term Mandatory,強制學術期限
+Quantity to Manufacture must be greater than 0.,量生產必須大於0。
+Calculate Prorated Depreciation Schedule Based on Fiscal Year,根據會計年度計算折舊折舊計劃
+Visit report for maintenance call.,訪問報告維修電話。
+Update Rate and Availability,更新率和可用性
+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.,相對於訂單量允許接受或交付的變動百分比額度。例如：如果你下定100個單位量，而你的許可額度是10%，那麼你可以收到最多110個單位量。
+Customer Group,客戶群組
+Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order # {3}. Please update operation status via Time Logs,行＃{0}：操作{1}未完成{2}工件訂單＃{3}中成品的數量。請通過時間日誌更新操作狀態
+New Batch ID (Optional),新批號（可選）
+New Batch ID (Optional),新批號（可選）
+Expense account is mandatory for item {0},交際費是強制性的項目{0}
+Website Description,網站簡介
+Net Change in Equity,在淨資產收益變化
+Please cancel Purchase Invoice {0} first,請取消採購發票{0}第一
+Not permitted. Please disable the Service Unit Type,不允許。請禁用服務單位類型
+"Email Address must be unique, already exists for {0}",電子郵件地址必須是唯一的，已經存在了{0}
+AMC Expiry Date,AMC到期時間
+Receipt,收據
+Sales Register,銷售登記
+Send Emails At,發送電子郵件在
+Quotation Lost Reason,報價遺失原因
+Transaction reference no {0} dated {1},交易參考編號{0}日{1}
+There is nothing to edit.,無內容可供編輯
+Form View,表單視圖
+Expense Approver Mandatory In Expense Claim,費用審批人必須在費用索賠中
+Summary for this month and pending activities,本月和待活動總結
+Please set Unrealized Exchange Gain/Loss Account in Company {0},請在公司{0}中設置未實現的匯兌收益/損失科目
+"Add users to your organization, other than yourself.",將用戶添加到您的組織，而不是您自己。
+Customer Group Name,客戶群組名稱
+No Customers yet!,還沒有客戶！
+Healthcare Service Unit,醫療服務單位
+Cash Flow Statement,現金流量表
+No material request created,沒有創建重要請求
+Loan Amount cannot exceed Maximum Loan Amount of {0},貸款額不能超過最高貸款額度{0}
+License,執照
+Please remove this Invoice {0} from C-Form {1},請刪除此發票{0}從C-表格{1}
+Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,請選擇結轉，如果你還需要包括上一會計年度的資產負債葉本財年
+Against Voucher Type,對憑證類型
+Phone (R),電話（R）
+Time slots added,添加時隙
+Attributes,屬性
+Enable Template,啟用模板
+Please enter Write Off Account,請輸入核銷科目
+Last Order Date,最後訂購日期
+Is Payable,應付
+B Negative,B負面
+Maintenance Status has to be Cancelled or Completed to Submit,維護狀態必須取消或完成提交
+US,我們
+Add Weekly Holidays,添加每週假期
+Vacancies,職位空缺
+Hotel Room,旅館房間
+Account {0} does not belongs to company {1},科目{0}不屬於公司{1}
+Rounding,四捨五入
+Serial Numbers in row {0} does not match with Delivery Note,行{0}中的序列號與交貨單不匹配
+Dispensed Amount (Pro-rated),分配金額（按比例分配）
+"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Group, Campaign, Sales Partner etc.",然後根據客戶，客戶組，地區，供應商，供應商組織，市場活動，銷售合作夥伴等篩選定價規則。
+Guardian Details,衛詳細
+Start Day,開始日
+Chassis No,底盤無
+Initiated,啟動
+Planned Start Date,計劃開始日期
+Please select a BOM,請選擇一個物料清單
+Availed ITC Integrated Tax,有效的ITC綜合稅收
+Blanket Order Rate,一攬子訂單費率
+Certification,證明
+Clauses and Conditions,條款和條件
+Creation Document Type,創建文件類型
+View Timesheet,查看時間表
+Make Journal Entry,使日記帳分錄
+New Leaves Allocated,新的排假
+Project-wise data is not available for Quotation,項目明智的數據不適用於報價
+End on,結束
+Expected End Date,預計結束日期
+Budget Amount,預算額
+Donor Name,捐助者名稱
+Inter Company Journal Entry Reference,Inter公司日記帳分錄參考
+Appraisal Template Title,評估模板標題
+Commercial,商業
+Alcohol Current Use,酒精當前使用
+House Rent Payment Amount,房屋租金付款金額
+Student Admission Program,學生入學計劃
+Tax Exemption Category,免稅類別
+Account Paid To,科目付至
+Grace Period,寬限期
+Alternative Item Name,替代項目名稱
+Parent Item {0} must not be a Stock Item,父項{0}不能是庫存產品
+Website Listing,網站列表
+All Products or Services.,所有的產品或服務。
+Open Quotations,打開報價單
+More Details,更多詳情
+Supplier Address,供應商地址
+{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0}預算科目{1}對{2} {3}是{4}。這將超過{5}
+Out Qty,輸出數量
+Series is mandatory,系列是強制性的
+Financial Services,金融服務
+Student ID,學生卡
+For Quantity must be greater than zero,對於數量必須大於零
+Types of activities for Time Logs,活動類型的時間記錄
+Sales,銷售
+Basic Amount,基本金額
+Exam,考試
+Marketplace Error,市場錯誤
+Warehouse required for stock Item {0},倉庫需要現貨產品{0}
+Make Repayment Entry,進行還款分錄
+All Departments,所有部門
+Alcohol Past Use,酒精過去使用
+Cr,鉻
+Problematic/Stuck,問題/卡住
+Billing State,計費狀態
+Transfer,轉讓
+Work Order {0} must be cancelled before cancelling this Sales Order,在取消此銷售訂單之前，必須先取消工單{0}
+Fetch exploded BOM (including sub-assemblies),取得爆炸BOM（包括子組件）
+Applicable To (Employee),適用於（員工）
+Due Date is mandatory,截止日期是強制性的
+Increment for Attribute {0} cannot be 0,增量屬性{0}不能為0,
+Benefit Type and Amount,福利類型和金額
+Rooms Booked,客房預訂
+Ends On date cannot be before Next Contact Date.,結束日期不能在下一次聯繫日期之前。
+Pay To / Recd From,支付/ 接收
+Setup Series,設置系列
+To Invoice Date,要發票日期
+Contact HTML,聯繫HTML,
+Support Portal,支持門戶
+Registration fee can not be Zero,註冊費不能為零
+Treatment Period,治療期
+Travel Itinerary,旅遊行程
+Result already Submitted,結果已提交
+Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,保留倉庫對於提供的原材料中的項目{0}是強制性的
+Inactive Customers,不活躍的客戶
+Maximum Age,最大年齡
+Please wait 3 days before resending the reminder.,請重新發送提醒之前請等待3天。
+Purchase Receipts,採購入庫
+How Pricing Rule is applied?,定價規則被如何應用？
+Delivery Note No,送貨單號
+Message to show,信息顯示
+Absent,缺席
+Staffing Plan Detail,人員配置計劃詳情
+Promotion Date,促銷日期
+Product Bundle,產品包
+Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,無法從{0}開始獲得分數。你需要有0到100的常規分數
+Row {0}: Invalid reference {1},行{0}：無效參考{1}
+Purchase Taxes and Charges Template,採購稅負和費用模板
+Current Invoice Start Date,當前發票開始日期
+{0} {1}: Either debit or credit amount is required for {2},{0} {1}：無論是借方或貸方金額需要{2}
+Remarks,備註
+Hotel Room Amenity,酒店客房舒適
+Action if Annual Budget Exceeded on MR,年度預算超出MR的行動
+Account Paid From,帳戶支付從
+Raw Material Item Code,原料產品編號
+Parent Task,父任務
+Write Off Based On,核銷的基礎上
+Make Lead,使鉛
+Show Barcode Field,顯示條形碼域
+Send Supplier Emails,發送電子郵件供應商
+"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.",工資已經處理了與{0}和{1}，留下申請期之間不能在此日期範圍內的時期。
+Auto Created,自動創建
+Submit this to create the Employee record,提交這個來創建員工記錄
+Item Default,項目默認值
+Leave Reason,離開原因
+Invoice {0} no longer exists,發票{0}不再存在
+Guardian Interest,衛利息
+Setup default values for POS Invoices,設置POS發票的默認值
+Training,訓練
+Time to send,發送時間
+Employee Detail,員工詳細信息
+Set warehouse for Procedure {0} ,為過程{0}設置倉庫
+Guardian1 Email ID,Guardian1電子郵件ID,
+Guardian1 Email ID,Guardian1電子郵件ID,
+Test Code,測試代碼
+Settings for website homepage,對網站的主頁設置
+{0} is on hold till {1},{0}一直保持到{1}
+RFQs are not allowed for {0} due to a scorecard standing of {1},由於{1}的記分卡，{0}不允許使用RFQ,
+Used Leaves,使用的葉子
+Awaiting Response,正在等待回應
+Link Options,鏈接選項
+Total Amount {0},總金額{0}
+Invalid attribute {0} {1},無效的屬性{0} {1}
+Mention if non-standard payable account,如果非標準應付帳款提到
+Please select the assessment group other than 'All Assessment Groups',請選擇“所有評估組”以外的評估組
+Row {0}: Cost center is required for an item {1},行{0}：項目{1}需要費用中心
+Optional,可選的
+{0} variants created.,創建了{0}個變體。
+Region,區域
+Optional. This setting will be used to filter in various transactions.,可選。此設置將被應用於過濾各種交易進行。
+Negative Valuation Rate is not allowed,負面評價率是不允許的
+Weekly Off,每週關閉
+Reload Linked Analysis,重新加載鏈接分析
+"For e.g. 2012, 2012-13",對於例如2012、2012-13,
+Provisional Profit / Loss (Credit),臨時溢利/（虧損）（信用）
+Return Against Sales Invoice,射向銷售發票
+Item 5,項目5,
+Creation Time,創作時間
+Total Revenue,總收入
+Other Risk Factors,其他風險因素
+Product Bundle Help,產品包幫助
+No record found,沒有資料
+Cost of Scrapped Asset,報廢資產成本
+{0} {1}: Cost Center is mandatory for Item {2},{0} {1}：成本中心是強制性的項目{2}
+Get Items from Product Bundle,從產品包取得項目
+Straight Line,直線
+Project User,項目用戶
+Re-allocate Leaves,重新分配葉子
+Is Advance,為進
+Employee Lifecycle,員工生命週期
+Attendance From Date and Attendance To Date is mandatory,考勤起始日期和出席的日期，是強制性的
+Please enter 'Is Subcontracted' as Yes or No,請輸入'轉包' YES或NO,
+Default Purchase Unit of Measure,默認採購單位
+Last Communication Date,最後通訊日期
+Last Communication Date,最後通訊日期
+Clinical Procedure Item,臨床流程項目
+Contact No.,聯絡電話
+Payment Entries,付款項
+Access token or Shopify URL missing,訪問令牌或Shopify網址丟失
+Latitude,緯度
+Scrap Warehouse,廢料倉庫
+"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}",在第{0}行，需要倉庫，請為公司{2}的物料{1}設置默認倉庫
+Check if material transfer entry is not required,檢查是否不需要材料轉移條目
+Check if material transfer entry is not required,檢查是否不需要材料轉移條目
+Get Students From,讓學生從
+Publish Items on Website,公佈於網頁上的項目
+Group your students in batches,一群學生在分批
+Authorization Rule,授權規則
+Terms and Conditions Details,條款及細則詳情
+Specifications,產品規格
+Sales Taxes and Charges Template,營業稅金及費用套版
+Total (Credit),總（信用）
+Apparel & Accessories,服裝及配飾
+Could not solve weighted score function. Make sure the formula is valid.,無法解決加權分數函數。確保公式有效。
+Purchase Order Items not received on time,未按時收到採購訂單項目
+Number of Order,訂購數量
+HTML / Banner that will show on the top of product list.,HTML／橫幅，將顯示在產品列表的頂部。
+Specify conditions to calculate shipping amount,指定條件來計算運費金額
+Institute's Bus,學院的巴士
+Role Allowed to Set Frozen Accounts & Edit Frozen Entries,允許設定凍結科目和編輯凍結分錄的角色
+Path,路徑
+Cannot convert Cost Center to ledger as it has child nodes,不能成本中心轉換為總賬，因為它有子節點
+Total Planned Qty,總計劃數量
+Opening Value,開度值
+Formula,式
+Serial #,序列號
+Lab Test Template,實驗室測試模板
+Sales Account,銷售科目
+Total Weight,總重量
+Commission on Sales,銷售佣金
+Value / Description,值/說明
+"Row #{0}: Asset {1} cannot be submitted, it is already {2}",行＃{0}：資產{1}無法提交，這已經是{2}
+Billing Country,結算國家
+Expected Delivery Date,預計交貨日期
+Restaurant Order Entry,餐廳訂單錄入
+Debit and Credit not equal for {0} #{1}. Difference is {2}.,借貸{0}＃不等於{1}。區別是{2}。
+Invoice Separately as Consumables,作為耗材單獨發票
+Control Action,控制行動
+Assign To Name,分配到名稱
+Entertainment Expenses,娛樂費用
+Make Material Request,製作材料要求
+Open Item {0},打開項目{0}
+Written Down Value,寫下價值
+Sales Invoice {0} must be cancelled before cancelling this Sales Order,銷售發票{0}必須早於此銷售訂單之前取消
+Age,年齡
+Billing Amount,開票金額
+Select Maximum Of 1,選擇最多1個
+Invalid quantity specified for item {0}. Quantity should be greater than 0.,為項目指定了無效的數量{0} 。量應大於0 。
+Default Employee Advance Account,默認員工高級帳戶
+Search Item (Ctrl + i),搜索項目（Ctrl + i）
+Account with existing transaction can not be deleted,科目與現有的交易不能被刪除
+Last Carbon Check,最後檢查炭
+Legal Expenses,法律費用
+Please select quantity on row ,請選擇行數量
+Make Opening Sales and Purchase Invoices,打開銷售和購買發票
+Posting Time,登錄時間
+% Amount Billed,（％）金額已開立帳單
+Telephone Expenses,電話費
+Logo,標誌
+Check this if you want to force the user to select a series before saving. There will be no default if you check this.,如果要強制用戶在儲存之前選擇了一系列，則勾選此項。如果您勾選此項，則將沒有預設值。
+No Item with Serial No {0},沒有序號{0}的品項
+Open Notifications,打開通知
+Difference Amount (Company Currency),差異金額（公司幣種）
+Direct Expenses,直接費用
+New Customer Revenue,新客戶收入
+Travel Expenses,差旅費
+Breakdown,展開
+Vegetarian,素
+Account: {0} with currency: {1} can not be selected,帳號：{0}幣種：{1}不能選擇
+Bank Data,銀行數據
+Sample Quantity,樣品數量
+"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.",根據最新的估值/價格清單率/最近的原材料採購率，通過計劃程序自動更新BOM成本。
+Account {0}: Parent account {1} does not belong to company: {2},科目{0}：上層科目{1}不屬於公司：{2}
+Successfully deleted all transactions related to this company!,成功刪除與該公司相關的所有交易！
+As on Date,隨著對日
+Enrollment Date,報名日期
+Out Patient SMS Alerts,輸出病人短信
+Probation,緩刑
+New Academic Year,新學年
+Return / Credit Note,返回/信用票據
+Auto insert Price List rate if missing,自動插入價目表率，如果丟失
+Total Paid Amount,總支付金額
+Transferred Qty,轉讓數量
+Navigating,導航
+Planning,規劃
+Signee,簽署人
+Issued,發行
+Repayment Start Date,還款開始日期
+Student Activity,學生活動
+Supplier Id,供應商編號
+Payment Gateway Details,支付網關細節
+Quantity should be greater than 0,量應大於0,
+Cash Entry,現金分錄
+Child nodes can be only created under 'Group' type nodes,子節點可以在&#39;集團&#39;類型的節點上創建
+Academic Year Name,學年名稱
+{0} not allowed to transact with {1}. Please change the Company.,不允許{0}與{1}進行交易。請更改公司。
+Contact Desc,聯絡倒序
+Send regular summary reports via Email.,使用電子郵件發送定期匯總報告。
+Please set default account in Expense Claim Type {0},請報銷類型設置默認科目{0}
+Available Leaves,可用的葉子
+Student Name,學生姓名
+Item Manager,項目經理
+Payroll Payable,應付職工薪酬
+Collection Datetime,收集日期時間
+Total Operating Cost,總營運成本
+Note: Item {0} entered multiple times,注：項目{0}多次輸入
+All Contacts.,所有聯絡人。
+Closed Documents,關閉的文件
+Manage Appointment Invoice submit and cancel automatically for Patient Encounter,管理約會發票提交並自動取消患者遭遇
+Referring Practitioner,轉介醫生
+Company Abbreviation,公司縮寫
+User {0} does not exist,用戶{0}不存在
+Day(s) after invoice date,發票日期後的天數
+Date of Commencement should be greater than Date of Incorporation,開始日期應大於公司註冊日期
+Signed On,簽名
+Party Type,黨的類型
+Payment Schedule,付款時間表
+Abbreviation,縮寫
+Payment Entry already exists,付款項目已存在
+Trial Period End Date,試用期結束日期
+Not authroized since {0} exceeds limits,不允許因為{0}超出範圍
+Asset Status,資產狀態
+Over Dimensional Cargo (ODC),超尺寸貨物（ODC）
+Hotel Manager,酒店經理
+Set Tax Rule for shopping cart,購物車稅收規則設定
+Taxes and Charges Added,稅費上架
+Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,折舊行{0}：下一個折舊日期不能在可供使用的日期之前
+Sales Funnel,銷售漏斗
+Abbreviation is mandatory,縮寫是強制性的
+Task Progress,任務進度
+Cart,車
+Total Estimated Budget,預計總預算
+Qty to Transfer,轉移數量
+Quotes to Leads or Customers.,行情到引線或客戶。
+Role Allowed to edit frozen stock,此角色可以編輯凍結的庫存
+Territory Target Variance Item Group-Wise,地域內跨項目群組間的目標差異
+All Customer Groups,所有客戶群組
+Accumulated Monthly,每月累計
+{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0}是強制性的。也許外幣兌換記錄為{1}到{2}尚未建立。
+Staffing Plan {0} already exist for designation {1},已存在人員配置計劃{0}以用於指定{1}
+Tax Template is mandatory.,稅務模板是強制性的。
+Account {0}: Parent account {1} does not exist,科目{0}：上層科目{1}不存在
+Period Start Date,期間開始日期
+Price List Rate (Company Currency),價格列表費率（公司貨幣）
+Products Settings,產品設置
+Item Price Stock,項目價格庫存
+To make Customer based incentive schemes.,制定基於客戶的激勵計劃。
+Test Created,測試創建
+Custom Signature in Print,自定義簽名打印
+Temporary,臨時
+Customer LPO No.,客戶LPO號
+Market Place Account Group,市場科目組
+Make Payment Entries,付款條目
+Courses,培訓班
+Percentage Allocation,百分比分配
+Secretary,秘書
+House rented dates required for exemption calculation,房子租用日期計算免責
+"If disable, 'In Words' field will not be visible in any transaction",如果禁用“，在詞”字段不會在任何交易可見
+This action will stop future billing. Are you sure you want to cancel this subscription?,此操作將停止未來的結算。您確定要取消此訂閱嗎？
+Distinct unit of an Item,一個項目的不同的單元
+Criteria Name,標準名稱
+Please set Company,請設公司
+Procedure Created,程序已創建
+Buying,採購
+Diseases & Fertilizers,疾病與肥料
+Employee Records to be created by,員工紀錄的創造者
+AB Negative,AB陰性
+Apply Discount On,申請折扣
+Membership Type,會員類型
+Reqd By Date,REQD按日期
+Creditors,債權人
+Assessment Name,評估名稱
+Show PDC in Print,在打印中顯示PDC,
+Row # {0}: Serial No is mandatory,行＃{0}：序列號是必需的
+Item Wise Tax Detail,項目智者稅制明細
+Job Offer,工作機會
+Institute Abbreviation,研究所縮寫
+Item-wise Price List Rate,全部項目的價格表
+Supplier Quotation,供應商報價
+In Words will be visible once you save the Quotation.,報價一被儲存，就會顯示出來。
+Quantity ({0}) cannot be a fraction in row {1},數量（{0}）不能是行{1}中的分數
+Quantity ({0}) cannot be a fraction in row {1},數量（{0}）不能是行{1}中的分數
+Unsigned,無符號
+Each Transaction,每筆交易
+Barcode {0} already used in Item {1},條碼{0}已經用在項目{1}
+Rules for adding shipping costs.,增加運輸成本的規則。
+Varaiance ,Varaiance,
+Opening Stock,打開庫存
+Customer is required,客戶是必需的
+Result Date,結果日期
+PDC/LC Date,PDC / LC日期
+To Receive,接受
+Holiday List for Optional Leave,可選假期的假期列表
+Asset Owner,資產所有者
+Reason For Putting On Hold,擱置的理由
+Personal Email,個人電子郵件
+Total Variance,總方差
+"If enabled, the system will post accounting entries for inventory automatically.",如果啟用，系統將自動為發布庫存會計分錄。
+Attendance for employee {0} is already marked for this day,考勤員工{0}已標記為這一天
+"in Minutes,
 Updated via 'Time Log'","在分
 經由“時間日誌”更新"
-DocType: Customer,From Lead,從鉛
-DocType: Amazon MWS Settings,Synch Orders,同步訂單
-apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,發布生產訂單。
-apps/erpnext/erpnext/public/js/account_tree_grid.js +65,Select Fiscal Year...,選擇會計年度...
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +639,POS Profile required to make POS Entry,所需的POS資料，使POS進入
-apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +15,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",忠誠度積分將根據所花費的完成量（通過銷售發票）計算得出。
-DocType: Company,HRA Settings,HRA設置
-DocType: Employee Transfer,Transfer Date,轉移日期
-apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,標準銷售
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +244,Atleast one warehouse is mandatory,至少要有一間倉庫
-apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py +14,"Configure Item Fields like UOM, Item Group, Description and No of Hours.",配置項目字段，如UOM，項目組，描述和小時數。
-DocType: Certification Application,Certification Status,認證狀態
-DocType: Travel Itinerary,Travel Advance Required,需要旅行預付款
-DocType: Subscriber,Subscriber Name,訂戶名稱
-DocType: Bank Statement Transaction Settings Item,Mapped Data Type,映射數據類型
-DocType: BOM Update Tool,Replace,更換
-apps/erpnext/erpnext/templates/includes/product_list.js +42,No products found.,找不到產品。
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +396,{0} against Sales Invoice {1},{0}針對銷售發票{1}
-DocType: Antibiotic,Laboratory User,實驗室用戶
-DocType: Request for Quotation Item,Project Name,專案名稱
-DocType: Customer,Mention if non-standard receivable account,提到如果不規範應收帳款
-apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +63,Please add the remaining benefits {0} to any of the existing component,請將其餘好處{0}添加到任何現有組件
-DocType: Journal Entry Account,If Income or Expense,如果收入或支出
-DocType: Bank Statement Transaction Entry,Matching Invoices,匹配發票
-DocType: Work Order,Required Items,所需物品
-DocType: Stock Ledger Entry,Stock Value Difference,庫存價值差異
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {0}: {1} {2} does not exist in above '{1}' table,項目行{0}：{1} {2}在上面的“{1}”表格中不存在
-apps/erpnext/erpnext/config/learn.py +229,Human Resource,人力資源
-DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,付款方式付款對賬
-DocType: Disease,Treatment Task,治療任務
-DocType: Payment Order Reference,Bank Account Details,銀行科目明細
-DocType: Purchase Order Item,Blanket Order,總訂單
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +39,Tax Assets,所得稅資產
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +631,Production Order has been {0},生產訂單已經{0}
-apps/erpnext/erpnext/regional/india/utils.py +186,House rent paid days overlap with {0},房租支付天數與{0}重疊
-DocType: BOM Item,BOM No,BOM No.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +192,Journal Entry {0} does not have account {1} or already matched against other voucher,日記條目{0}沒有帳號{1}或已經匹配其他憑證
-DocType: Item,Moving Average,移動平均線
-DocType: BOM Update Tool,The BOM which will be replaced,這將被替換的物料清單
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +47,Electronic Equipments,電子設備
-DocType: Asset,Maintenance Required,需要維護
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +63,Leaves must be allocated in multiples of 0.5,休假必須安排成0.5倍的
-DocType: Work Order,Operation Cost,運營成本
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +223,Identifying Decision Makers,確定決策者
-apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Outstanding Amt,優秀的金額
-DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,為此銷售人員設定跨項目群組間的目標。
-DocType: Stock Settings,Freeze Stocks Older Than [Days],凍結早於[Days]的庫存
-DocType: Payment Request,Payment Ordered,付款訂購
-DocType: Asset Maintenance Team,Maintenance Team Name,維護組名稱
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42,"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.",如果兩個或更多的定價規則是基於上述條件發現，優先級被應用。優先權是一個介於0到20，而預設值是零（空）。數字越大，意味著其將優先考慮是否有與相同條件下多個定價規則。
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +197,Customer is mandatory if 'Opportunity From' is selected as Customer,如果選擇“機會來源”作為客戶，則客戶是強制性的
-apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,會計年度：{0}不存在
-DocType: Currency Exchange,To Currency,到貨幣
-DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,允許以下用戶批准許可申請的區塊天。
-apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +30,Lifecycle,生命週期
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +142,Make BOM,製作BOM
-apps/erpnext/erpnext/controllers/selling_controller.py +161,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},項目{0}的銷售價格低於其{1}。售價應至少為{2}
-apps/erpnext/erpnext/controllers/selling_controller.py +161,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},項目{0}的銷售價格低於其{1}。售價應至少為{2}
-DocType: Subscription,Taxes,稅
-DocType: Purchase Invoice,capital goods,資本貨物
-DocType: Purchase Invoice Item,Weight Per Unit,每單位重量
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +363,Paid and Not Delivered,支付和未送達
-DocType: QuickBooks Migrator,Default Cost Center,預設的成本中心
-apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,庫存交易明細
-DocType: Budget,Budget Accounts,預算科目
-DocType: Employee,Internal Work History,內部工作經歷
-DocType: Depreciation Schedule,Accumulated Depreciation Amount,累計折舊額
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42,Private Equity,私募股權投資
-DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,供應商記分卡變數
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +75,Please create purchase receipt or purchase invoice for the item {0},請為項目{0}創建購買收據或購買發票
-DocType: Employee Advance,Due Advance Amount,到期金額
-DocType: Maintenance Visit,Customer Feedback,客戶反饋
-DocType: Account,Expense,費用
-apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +48,Score cannot be greater than Maximum Score,分數不能超過最高得分更大
-DocType: Support Search Source,Source Type,來源類型
-apps/erpnext/erpnext/utilities/user_progress.py +129,Customers and Suppliers,客戶和供應商
-DocType: Item Attribute,From Range,從範圍
-DocType: BOM,Set rate of sub-assembly item based on BOM,基於BOM設置子組合項目的速率
-DocType: Inpatient Occupancy,Invoiced,已開發票
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +179,Syntax error in formula or condition: {0},式或條件語法錯誤：{0}
-DocType: Daily Work Summary Settings Company,Daily Work Summary Settings Company,每日工作總結公司的設置
-apps/erpnext/erpnext/stock/utils.py +149,Item {0} ignored since it is not a stock item,項目{0}被忽略，因為它不是一個庫存項目
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.",要在一個特定的交易不適用於定價規則，所有適用的定價規則應該被禁用。
-DocType: Payment Term,Day(s) after the end of the invoice month,發票月份結束後的一天
-DocType: Assessment Group,Parent Assessment Group,家長評估小組
-,Sales Order Trends,銷售訂單趨勢
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,The 'From Package No.' field must neither be empty nor it's value less than 1.,“From Package No.”字段不能為空，也不能小於1。
-DocType: Employee,Held On,舉行
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +36,Production Item,生產項目
-,Employee Information,僱員資料
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +242,Healthcare Practitioner not available on {0},醫療從業者在{0}上不可用
-DocType: Stock Entry Detail,Additional Cost,額外費用
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +57,"Can not filter based on Voucher No, if grouped by Voucher",是凍結的帳戶。要禁止該帳戶創建/編輯事務，你需要有指定的身份
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +975,Make Supplier Quotation,讓供應商報價
-DocType: Quality Inspection,Incoming,來
-apps/erpnext/erpnext/setup/doctype/company/company.js +90,Default tax templates for sales and purchase are created.,銷售和採購的默認稅收模板被創建。
-apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +44,Assessment Result record {0} already exists.,評估結果記錄{0}已經存在。
-DocType: Item,"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.",例如：ABCD。#####。如果系列已設置且交易中未提及批號，則將根據此系列創建自動批號。如果您始終想要明確提及此料品的批號，請將此留為空白。注意：此設置將優先於庫存設置中的命名系列前綴。
-DocType: BOM,Materials Required (Exploded),所需材料（分解）
-DocType: Contract,Party User,派對用戶
-apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60,Please set Company filter blank if Group By is 'Company',如果Group By是“Company”，請設置公司過濾器空白
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +68,Posting Date cannot be future date,發布日期不能是未來的日期
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +100,Row # {0}: Serial No {1} does not match with {2} {3},行＃{0}：序列號{1}不相匹配{2} {3}
-DocType: Stock Entry,Target Warehouse Address,目標倉庫地址
-DocType: Agriculture Task,End Day,結束的一天
-,Delivery Note Trends,送貨單趨勢
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +120,This Week's Summary,本週的總結
-apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +24,In Stock Qty,庫存數量
-,Daily Work Summary Replies,日常工作總結回复
-DocType: Delivery Trip,Calculate Estimated Arrival Times,計算預計到達時間
-apps/erpnext/erpnext/accounts/general_ledger.py +113,Account: {0} can only be updated via Stock Transactions,帳號：{0}只能通過庫存的交易進行更新
-DocType: Student Group Creation Tool,Get Courses,獲取課程
-DocType: Shopify Settings,Webhooks,網絡掛接
-DocType: Bank Account,Party,黨
-DocType: Variant Field,Variant Field,變種場
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +370,Target Location,目標位置
-DocType: Sales Order,Delivery Date,交貨日期
-DocType: Opportunity,Opportunity Date,機會日期
-DocType: Employee,Health Insurance Provider,健康保險提供者
-DocType: Products Settings,Show Availability Status,顯示可用性狀態
-DocType: Purchase Receipt,Return Against Purchase Receipt,採購入庫的退貨
-DocType: Water Analysis,Person Responsible,負責人
-DocType: Request for Quotation Item,Request for Quotation Item,詢價項目
-DocType: Purchase Order,To Bill,發票待輸入
-DocType: Material Request,% Ordered,% 已訂購
-DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",對於基於課程的學生小組，課程將從入學課程中的每個學生確認。
-DocType: Employee Grade,Employee Grade,員工等級
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +81,Piecework,計件工作
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +68,Avg. Buying Rate,平均。買入價
-DocType: Share Balance,From No,來自No
-DocType: Task,Actual Time (in Hours),實際時間（小時）
-DocType: Employee,History In Company,公司歷史
-DocType: Customer,Customer Primary Address,客戶主要地址
-apps/erpnext/erpnext/config/learn.py +107,Newsletters,簡訊
-apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py +175,Reference No.,參考編號。
-DocType: Drug Prescription,Description/Strength,說明/力量
-DocType: Bank Statement Transaction Entry,Create New Payment/Journal Entry,創建新的付款/日記賬分錄
-DocType: Certification Application,Certification Application,認證申請
-DocType: Leave Type,Is Optional Leave,是可選的休假
-DocType: Share Balance,Is Company,是公司
-DocType: Stock Ledger Entry,Stock Ledger Entry,庫存總帳條目
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +190,{0} on Half day Leave on {1},半天{0}離開{1}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +87,Same item has been entered multiple times,同一項目已進入多次
-DocType: Department,Leave Block List,休假區塊清單
-DocType: Purchase Invoice,Tax ID,稅號
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198,Item {0} is not setup for Serial Nos. Column must be blank,項目{0}不是設定為序列號，此列必須為空白
-DocType: Accounts Settings,Accounts Settings,會計設定
-DocType: Loyalty Program,Customer Territory,客戶地區
-DocType: Email Digest,Sales Orders to Deliver,要交付的銷售訂單
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28,"Number of new Account, it will be included in the account name as a prefix",新帳號的數量，將作為前綴包含在帳號名稱中
-DocType: Maintenance Team Member,Team Member,隊員
-apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151,No Result to submit,沒有結果提交
-DocType: Customer,Sales Partner and Commission,銷售合作夥伴及佣金
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'",共有{0}所有項目為零，可能是你應該“基於分佈式費用”改變
-apps/erpnext/erpnext/hr/utils.py +152,To date can not be less than from date,迄今為止不能少於起始日期
-DocType: Opportunity,To Discuss,為了討論
-apps/erpnext/erpnext/stock/stock_ledger.py +382,{0} units of {1} needed in {2} to complete this transaction.,{0}單位{1}在{2}完成此交易所需。
-DocType: Support Settings,Forum URL,論壇URL
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +75,Temporary Accounts,臨時科目
-apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +40,Source Location is required for the asset {0},源位置對資產{0}是必需的
-DocType: BOM Explosion Item,BOM Explosion Item,BOM展開項目
-DocType: Shareholder,Contact List,聯繫人列表
-DocType: Account,Auditor,核數師
-DocType: Project,Frequency To Collect Progress,頻率收集進展
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +254,{0} items produced,生產{0}項目
-apps/erpnext/erpnext/utilities/user_progress.py +58,Learn More,學到更多
-DocType: Cheque Print Template,Distance from top edge,從頂邊的距離
-DocType: POS Closing Voucher Invoices,Quantity of Items,項目數量
-apps/erpnext/erpnext/stock/get_item_details.py +521,Price List {0} is disabled or does not exist,價格表{0}禁用或不存在
-DocType: Purchase Invoice,Return,退貨
-DocType: Pricing Rule,Disable,關閉
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +184,Mode of payment is required to make a payment,付款方式需要進行付款
-DocType: Project Task,Pending Review,待審核
-apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14,"Edit in full page for more options like assets, serial nos, batches etc.",在整頁上編輯更多選項，如資產，序列號，批次等。
-DocType: Leave Type,Maximum Continuous Days Applicable,最大持續天數適用
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0}  -  {1} 未在批次處理中註冊 {2}
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +118,"Asset {0} cannot be scrapped, as it is already {1}",資產{0}不能被廢棄，因為它已經是{1}
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +93,Cheques Required,需要檢查
-DocType: Task,Total Expense Claim (via Expense Claim),總費用報銷（通過費用報銷）
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,馬克缺席
-DocType: Job Applicant Source,Job Applicant Source,求職者來源
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +328,IGST Amount,IGST金額
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +41,Failed to setup company,未能成立公司
-DocType: Asset Repair,Asset Repair,資產修復
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +155,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},行{0}：BOM＃的貨幣{1}應等於所選貨幣{2}
-DocType: Journal Entry Account,Exchange Rate,匯率
-DocType: Patient,Additional information regarding the patient,有關患者的其他信息
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +657,Sales Order {0} is not submitted,銷售訂單{0}未提交
-DocType: Homepage,Tag Line,標語
-DocType: Fee Component,Fee Component,收費組件
-apps/erpnext/erpnext/config/hr.py +286,Fleet Management,車隊的管理
-DocType: Fertilizer,Density (if liquid),密度（如果液體）
-apps/erpnext/erpnext/education/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,所有評估標準的權重總數要達到100％
-DocType: Purchase Order Item,Last Purchase Rate,最後預訂價
-DocType: Account,Asset,財富
-DocType: Project Task,Task ID,任務ID
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84,Stock cannot exist for Item {0} since has variants,庫存可以為項目不存在{0}，因為有變種
-DocType: Healthcare Practitioner,Mobile,移動
-,Sales Person-wise Transaction Summary,銷售人員相關的交易匯總
-DocType: Training Event,Contact Number,聯繫電話
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0} does not exist,倉庫{0}不存在
-DocType: Employee Tax Exemption Proof Submission Detail,Employee Tax Exemption Proof Submission Detail,員工免稅證明提交細節
-DocType: Monthly Distribution,Monthly Distribution Percentages,每月分佈百分比
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +115,The selected item cannot have Batch,所選項目不能批
-DocType: Delivery Note,% of materials delivered against this Delivery Note,針對這張送貨單物料已交貨的百分比(%)
-DocType: Asset Maintenance Log,Has Certificate,有證書
-DocType: Project,Customer Details,客戶詳細資訊
-DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,檢查資產是否需要預防性維護或校準
-apps/erpnext/erpnext/public/js/setup_wizard.js +87,Company Abbreviation cannot have more than 5 characters,公司縮寫不能超過5個字符
-DocType: Employee,Reports to,隸屬於
-,Unpaid Expense Claim,未付費用報銷
-DocType: Payment Entry,Paid Amount,支付的金額
-apps/erpnext/erpnext/utilities/user_progress.py +158,Explore Sales Cycle,探索銷售週期
-DocType: Assessment Plan,Supervisor,監
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +934,Retention Stock Entry,保留庫存入場
-,Available Stock for Packing Items,可用庫存包裝項目
-DocType: Item Variant,Item Variant,項目變
-,Work Order Stock Report,工單庫存報表
-DocType: Purchase Receipt,Auto Repeat Detail,自動重複細節
-DocType: Assessment Result Tool,Assessment Result Tool,評價結果工具
-apps/erpnext/erpnext/education/doctype/instructor/instructor.js +45,As Supervisor,作為主管
-DocType: Leave Policy Detail,Leave Policy Detail,退出政策細節
-DocType: BOM Scrap Item,BOM Scrap Item,BOM項目廢料
-apps/erpnext/erpnext/accounts/page/pos/pos.js +906,Submitted orders can not be deleted,提交的訂單不能被刪除
-apps/erpnext/erpnext/accounts/doctype/account/account.py +121,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'",科目餘額已歸為借方科目，不允許設為貸方
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +391,Quality Management,品質管理
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +52,Item {0} has been disabled,項{0}已被禁用
-DocType: Project,Total Billable Amount (via Timesheets),總計費用金額（通過時間表）
-DocType: Agriculture Task,Previous Business Day,前一個營業日
-DocType: Loan,Repay Fixed Amount per Period,償還每期固定金額
-DocType: Employee,Health Insurance No,健康保險No
-DocType: Employee Tax Exemption Proof Submission,Tax Exemption Proofs,免稅證明
-apps/erpnext/erpnext/buying/utils.py +47,Please enter quantity for Item {0},請輸入項目{0}的量
-apps/erpnext/erpnext/regional/report/hsn_wise_summary_of_outward_supplies/hsn_wise_summary_of_outward_supplies.py +78,Total Taxable Amount,應納稅總額
-DocType: Employee External Work History,Employee External Work History,員工對外工作歷史
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +691,Job card {0} created,已創建作業卡{0}
-DocType: Opening Invoice Creation Tool,Purchase,採購
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,餘額數量
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,目標不能為空
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +18,Enrolling students,招收學生
-DocType: Item Group,Parent Item Group,父項目群組
-DocType: Appointment Type,Appointment Type,預約類型
-apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0}for {1}
-DocType: Healthcare Settings,Valid number of days,有效天數
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +19,Restart Subscription,重新啟動訂閱
-DocType: Linked Plant Analysis,Linked Plant Analysis,鏈接的工廠分析
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +358,Transporter ID,運輸商ID
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +222,Value Proposition,價值主張
-DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,供應商貨幣被換算成公司基礎貨幣的匯率
-DocType: Purchase Invoice Item,Service End Date,服務結束日期
-apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},行＃{0}：與排時序衝突{1}
-DocType: Purchase Invoice Item,Allow Zero Valuation Rate,允許零估值
-DocType: Purchase Invoice Item,Allow Zero Valuation Rate,允許零估值
-DocType: Training Event Employee,Invited,邀請
-apps/erpnext/erpnext/config/accounts.py +276,Setup Gateway accounts.,設置閘道科目。
-DocType: Employee,Employment Type,就業類型
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43,Fixed Assets,固定資產
-DocType: Payment Entry,Set Exchange Gain / Loss,設置兌換收益/損失
-,GST Purchase Register,消費稅購買登記冊
-,Cash Flow,現金周轉
-apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25,Combined invoice portion must equal 100%,合併發票部分必須等於100％
-DocType: Item Default,Default Expense Account,預設費用科目
-DocType: GST Account,CGST Account,CGST科目
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,學生的電子郵件ID
-DocType: POS Closing Voucher Invoices,POS Closing Voucher Invoices,POS關閉憑證發票
-DocType: Tax Rule,Sales Tax Template,銷售稅模板
-DocType: Employee Benefit Application Detail,Pay Against Benefit Claim,支付利益索賠
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +21,Update Cost Center Number,更新成本中心編號
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2524,Select items to save the invoice,選取要保存發票
-DocType: Employee,Encashment Date,兌現日期
-DocType: Training Event,Internet,互聯網
-DocType: Special Test Template,Special Test Template,特殊測試模板
-DocType: Account,Stock Adjustment,庫存調整
-apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34,Default Activity Cost exists for Activity Type - {0},默認情況下存在作業成本的活動類型 -  {0}
-DocType: Work Order,Planned Operating Cost,計劃運營成本
-DocType: Academic Term,Term Start Date,期限起始日期
-apps/erpnext/erpnext/config/accounts.py +440,List of all share transactions,所有股份交易清單
-DocType: Supplier,Is Transporter,是運輸車
-DocType: Shopify Settings,Import Sales Invoice from Shopify if Payment is marked,如果付款已標記，則從Shopify導入銷售發票
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opp Count
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opp Count
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +218,Both Trial Period Start Date and Trial Period End Date must be set,必須設置試用期開始日期和試用期結束日期
-apps/erpnext/erpnext/controllers/accounts_controller.py +808,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,支付計劃中的總付款金額必須等於大/圓
-DocType: Subscription Plan Detail,Plan,計劃
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,銀行對賬單餘額按總帳
-DocType: Job Applicant,Applicant Name,申請人名稱
-DocType: Authorization Rule,Customer / Item Name,客戶／品項名稱
-DocType: Product Bundle,"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 
+From Lead,從鉛
+Synch Orders,同步訂單
+Orders released for production.,發布生產訂單。
+Select Fiscal Year...,選擇會計年度...
+POS Profile required to make POS Entry,所需的POS資料，使POS進入
+"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",忠誠度積分將根據所花費的完成量（通過銷售發票）計算得出。
+HRA Settings,HRA設置
+Transfer Date,轉移日期
+Standard Selling,標準銷售
+Atleast one warehouse is mandatory,至少要有一間倉庫
+"Configure Item Fields like UOM, Item Group, Description and No of Hours.",配置項目字段，如UOM，項目組，描述和小時數。
+Certification Status,認證狀態
+Travel Advance Required,需要旅行預付款
+Subscriber Name,訂戶名稱
+Mapped Data Type,映射數據類型
+Replace,更換
+No products found.,找不到產品。
+{0} against Sales Invoice {1},{0}針對銷售發票{1}
+Laboratory User,實驗室用戶
+Project Name,專案名稱
+Mention if non-standard receivable account,提到如果不規範應收帳款
+Please add the remaining benefits {0} to any of the existing component,請將其餘好處{0}添加到任何現有組件
+If Income or Expense,如果收入或支出
+Matching Invoices,匹配發票
+Required Items,所需物品
+Stock Value Difference,庫存價值差異
+Item Row {0}: {1} {2} does not exist in above '{1}' table,項目行{0}：{1} {2}在上面的“{1}”表格中不存在
+Human Resource,人力資源
+Payment Reconciliation Payment,付款方式付款對賬
+Treatment Task,治療任務
+Bank Account Details,銀行科目明細
+Blanket Order,總訂單
+Tax Assets,所得稅資產
+Production Order has been {0},生產訂單已經{0}
+House rent paid days overlap with {0},房租支付天數與{0}重疊
+BOM No,BOM No.
+Journal Entry {0} does not have account {1} or already matched against other voucher,日記條目{0}沒有帳號{1}或已經匹配其他憑證
+Moving Average,移動平均線
+The BOM which will be replaced,這將被替換的物料清單
+Electronic Equipments,電子設備
+Maintenance Required,需要維護
+Leaves must be allocated in multiples of 0.5,休假必須安排成0.5倍的
+Operation Cost,運營成本
+Identifying Decision Makers,確定決策者
+Outstanding Amt,優秀的金額
+Set targets Item Group-wise for this Sales Person.,為此銷售人員設定跨項目群組間的目標。
+Freeze Stocks Older Than [Days],凍結早於[Days]的庫存
+Payment Ordered,付款訂購
+Maintenance Team Name,維護組名稱
+"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.",如果兩個或更多的定價規則是基於上述條件發現，優先級被應用。優先權是一個介於0到20，而預設值是零（空）。數字越大，意味著其將優先考慮是否有與相同條件下多個定價規則。
+Customer is mandatory if 'Opportunity From' is selected as Customer,如果選擇“機會來源”作為客戶，則客戶是強制性的
+Fiscal Year: {0} does not exists,會計年度：{0}不存在
+To Currency,到貨幣
+Allow the following users to approve Leave Applications for block days.,允許以下用戶批准許可申請的區塊天。
+Lifecycle,生命週期
+Make BOM,製作BOM,
+Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},項目{0}的銷售價格低於其{1}。售價應至少為{2}
+Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},項目{0}的銷售價格低於其{1}。售價應至少為{2}
+Taxes,稅
+capital goods,資本貨物
+Weight Per Unit,每單位重量
+Paid and Not Delivered,支付和未送達
+Default Cost Center,預設的成本中心
+Stock Transactions,庫存交易明細
+Budget Accounts,預算科目
+Internal Work History,內部工作經歷
+Accumulated Depreciation Amount,累計折舊額
+Private Equity,私募股權投資
+Supplier Scorecard Variable,供應商記分卡變數
+Please create purchase receipt or purchase invoice for the item {0},請為項目{0}創建購買收據或購買發票
+Due Advance Amount,到期金額
+Customer Feedback,客戶反饋
+Expense,費用
+Score cannot be greater than Maximum Score,分數不能超過最高得分更大
+Source Type,來源類型
+Customers and Suppliers,客戶和供應商
+From Range,從範圍
+Set rate of sub-assembly item based on BOM,基於BOM設置子組合項目的速率
+Invoiced,已開發票
+Syntax error in formula or condition: {0},式或條件語法錯誤：{0}
+Daily Work Summary Settings Company,每日工作總結公司的設置
+Item {0} ignored since it is not a stock item,項目{0}被忽略，因為它不是一個庫存項目
+"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.",要在一個特定的交易不適用於定價規則，所有適用的定價規則應該被禁用。
+Day(s) after the end of the invoice month,發票月份結束後的一天
+Parent Assessment Group,家長評估小組
+Sales Order Trends,銷售訂單趨勢
+The 'From Package No.' field must neither be empty nor it's value less than 1.,“From Package No.”字段不能為空，也不能小於1。
+Held On,舉行
+Production Item,生產項目
+Employee Information,僱員資料
+Healthcare Practitioner not available on {0},醫療從業者在{0}上不可用
+Additional Cost,額外費用
+"Can not filter based on Voucher No, if grouped by Voucher",是凍結的帳戶。要禁止該帳戶創建/編輯事務，你需要有指定的身份
+Make Supplier Quotation,讓供應商報價
+Incoming,來
+Default tax templates for sales and purchase are created.,銷售和採購的默認稅收模板被創建。
+Assessment Result record {0} already exists.,評估結果記錄{0}已經存在。
+"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.",例如：ABCD。#####。如果系列已設置且交易中未提及批號，則將根據此系列創建自動批號。如果您始終想要明確提及此料品的批號，請將此留為空白。注意：此設置將優先於庫存設置中的命名系列前綴。
+Materials Required (Exploded),所需材料（分解）
+Party User,派對用戶
+Please set Company filter blank if Group By is 'Company',如果Group By是“Company”，請設置公司過濾器空白
+Posting Date cannot be future date,發布日期不能是未來的日期
+Row # {0}: Serial No {1} does not match with {2} {3},行＃{0}：序列號{1}不相匹配{2} {3}
+Target Warehouse Address,目標倉庫地址
+End Day,結束的一天
+Delivery Note Trends,送貨單趨勢
+This Week's Summary,本週的總結
+In Stock Qty,庫存數量
+Daily Work Summary Replies,日常工作總結回复
+Calculate Estimated Arrival Times,計算預計到達時間
+Account: {0} can only be updated via Stock Transactions,帳號：{0}只能通過庫存的交易進行更新
+Get Courses,獲取課程
+Webhooks,網絡掛接
+Party,黨
+Variant Field,變種場
+Target Location,目標位置
+Delivery Date,交貨日期
+Opportunity Date,機會日期
+Health Insurance Provider,健康保險提供者
+Show Availability Status,顯示可用性狀態
+Return Against Purchase Receipt,採購入庫的退貨
+Person Responsible,負責人
+Request for Quotation Item,詢價項目
+To Bill,發票待輸入
+% Ordered,% 已訂購
+"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",對於基於課程的學生小組，課程將從入學課程中的每個學生確認。
+Employee Grade,員工等級
+Piecework,計件工作
+Avg. Buying Rate,平均。買入價
+From No,來自No,
+Actual Time (in Hours),實際時間（小時）
+History In Company,公司歷史
+Customer Primary Address,客戶主要地址
+Newsletters,簡訊
+Reference No.,參考編號。
+Description/Strength,說明/力量
+Create New Payment/Journal Entry,創建新的付款/日記賬分錄
+Certification Application,認證申請
+Is Optional Leave,是可選的休假
+Is Company,是公司
+Stock Ledger Entry,庫存總帳條目
+{0} on Half day Leave on {1},半天{0}離開{1}
+Same item has been entered multiple times,同一項目已進入多次
+Leave Block List,休假區塊清單
+Tax ID,稅號
+Item {0} is not setup for Serial Nos. Column must be blank,項目{0}不是設定為序列號，此列必須為空白
+Accounts Settings,會計設定
+Customer Territory,客戶地區
+Sales Orders to Deliver,要交付的銷售訂單
+"Number of new Account, it will be included in the account name as a prefix",新帳號的數量，將作為前綴包含在帳號名稱中
+Team Member,隊員
+No Result to submit,沒有結果提交
+Sales Partner and Commission,銷售合作夥伴及佣金
+"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'",共有{0}所有項目為零，可能是你應該“基於分佈式費用”改變
+To date can not be less than from date,迄今為止不能少於起始日期
+To Discuss,為了討論
+{0} units of {1} needed in {2} to complete this transaction.,{0}單位{1}在{2}完成此交易所需。
+Forum URL,論壇URL,
+Temporary Accounts,臨時科目
+Source Location is required for the asset {0},源位置對資產{0}是必需的
+BOM Explosion Item,BOM展開項目
+Contact List,聯繫人列表
+Auditor,核數師
+Frequency To Collect Progress,頻率收集進展
+{0} items produced,生產{0}項目
+Learn More,學到更多
+Distance from top edge,從頂邊的距離
+Quantity of Items,項目數量
+Price List {0} is disabled or does not exist,價格表{0}禁用或不存在
+Return,退貨
+Disable,關閉
+Mode of payment is required to make a payment,付款方式需要進行付款
+Pending Review,待審核
+"Edit in full page for more options like assets, serial nos, batches etc.",在整頁上編輯更多選項，如資產，序列號，批次等。
+Maximum Continuous Days Applicable,最大持續天數適用
+{0} - {1} is not enrolled in the Batch {2},{0}  -  {1} 未在批次處理中註冊 {2}
+"Asset {0} cannot be scrapped, as it is already {1}",資產{0}不能被廢棄，因為它已經是{1}
+Cheques Required,需要檢查
+Total Expense Claim (via Expense Claim),總費用報銷（通過費用報銷）
+Mark Absent,馬克缺席
+Job Applicant Source,求職者來源
+IGST Amount,IGST金額
+Failed to setup company,未能成立公司
+Asset Repair,資產修復
+Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},行{0}：BOM＃的貨幣{1}應等於所選貨幣{2}
+Exchange Rate,匯率
+Additional information regarding the patient,有關患者的其他信息
+Sales Order {0} is not submitted,銷售訂單{0}未提交
+Tag Line,標語
+Fee Component,收費組件
+Fleet Management,車隊的管理
+Density (if liquid),密度（如果液體）
+Total Weightage of all Assessment Criteria must be 100%,所有評估標準的權重總數要達到100％
+Last Purchase Rate,最後預訂價
+Asset,財富
+Task ID,任務ID,
+Stock cannot exist for Item {0} since has variants,庫存可以為項目不存在{0}，因為有變種
+Mobile,移動
+Sales Person-wise Transaction Summary,銷售人員相關的交易匯總
+Contact Number,聯繫電話
+Warehouse {0} does not exist,倉庫{0}不存在
+Employee Tax Exemption Proof Submission Detail,員工免稅證明提交細節
+Monthly Distribution Percentages,每月分佈百分比
+The selected item cannot have Batch,所選項目不能批
+% of materials delivered against this Delivery Note,針對這張送貨單物料已交貨的百分比(%)
+Has Certificate,有證書
+Customer Details,客戶詳細資訊
+Check if Asset requires Preventive Maintenance or Calibration,檢查資產是否需要預防性維護或校準
+Company Abbreviation cannot have more than 5 characters,公司縮寫不能超過5個字符
+Reports to,隸屬於
+Unpaid Expense Claim,未付費用報銷
+Paid Amount,支付的金額
+Explore Sales Cycle,探索銷售週期
+Supervisor,監
+Retention Stock Entry,保留庫存入場
+Available Stock for Packing Items,可用庫存包裝項目
+Item Variant,項目變
+Work Order Stock Report,工單庫存報表
+Auto Repeat Detail,自動重複細節
+Assessment Result Tool,評價結果工具
+As Supervisor,作為主管
+Leave Policy Detail,退出政策細節
+BOM Scrap Item,BOM項目廢料
+Submitted orders can not be deleted,提交的訂單不能被刪除
+"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'",科目餘額已歸為借方科目，不允許設為貸方
+Quality Management,品質管理
+Item {0} has been disabled,項{0}已被禁用
+Total Billable Amount (via Timesheets),總計費用金額（通過時間表）
+Previous Business Day,前一個營業日
+Repay Fixed Amount per Period,償還每期固定金額
+Health Insurance No,健康保險No,
+Tax Exemption Proofs,免稅證明
+Please enter quantity for Item {0},請輸入項目{0}的量
+Total Taxable Amount,應納稅總額
+Employee External Work History,員工對外工作歷史
+Job card {0} created,已創建作業卡{0}
+Purchase,採購
+Balance Qty,餘額數量
+Goals cannot be empty,目標不能為空
+Enrolling students,招收學生
+Parent Item Group,父項目群組
+Appointment Type,預約類型
+{0} for {1},{0}for {1}
+Valid number of days,有效天數
+Restart Subscription,重新啟動訂閱
+Linked Plant Analysis,鏈接的工廠分析
+Transporter ID,運輸商ID,
+Value Proposition,價值主張
+Rate at which supplier's currency is converted to company's base currency,供應商貨幣被換算成公司基礎貨幣的匯率
+Service End Date,服務結束日期
+Row #{0}: Timings conflicts with row {1},行＃{0}：與排時序衝突{1}
+Allow Zero Valuation Rate,允許零估值
+Allow Zero Valuation Rate,允許零估值
+Invited,邀請
+Setup Gateway accounts.,設置閘道科目。
+Employment Type,就業類型
+Fixed Assets,固定資產
+Set Exchange Gain / Loss,設置兌換收益/損失
+GST Purchase Register,消費稅購買登記冊
+Cash Flow,現金周轉
+Combined invoice portion must equal 100%,合併發票部分必須等於100％
+Default Expense Account,預設費用科目
+CGST Account,CGST科目
+Student Email ID,學生的電子郵件ID,
+POS Closing Voucher Invoices,POS關閉憑證發票
+Sales Tax Template,銷售稅模板
+Pay Against Benefit Claim,支付利益索賠
+Update Cost Center Number,更新成本中心編號
+Select items to save the invoice,選取要保存發票
+Encashment Date,兌現日期
+Internet,互聯網
+Special Test Template,特殊測試模板
+Stock Adjustment,庫存調整
+Default Activity Cost exists for Activity Type - {0},默認情況下存在作業成本的活動類型 -  {0}
+Planned Operating Cost,計劃運營成本
+Term Start Date,期限起始日期
+List of all share transactions,所有股份交易清單
+Is Transporter,是運輸車
+Import Sales Invoice from Shopify if Payment is marked,如果付款已標記，則從Shopify導入銷售發票
+Opp Count,Opp Count,
+Opp Count,Opp Count,
+Both Trial Period Start Date and Trial Period End Date must be set,必須設置試用期開始日期和試用期結束日期
+Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,支付計劃中的總付款金額必須等於大/圓
+Plan,計劃
+Bank Statement balance as per General Ledger,銀行對賬單餘額按總帳
+Applicant Name,申請人名稱
+Customer / Item Name,客戶／品項名稱
+"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 
 
 The package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".
 
 For Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.
 
 Note: BOM = Bill of Materials",聚合組** **項目到另一個項目** **的。如果你是捆綁了一定**項目你保持庫存的包裝**項目的**，而不是聚集**項這是一個有用的**到一個包和**。包** **項目將有“是庫存項目”為“否”和“是銷售項目”為“是”。例如：如果你是銷售筆記本電腦和背包分開，並有一個特殊的價格，如果客戶購買兩個，那麼筆記本電腦+背包將是一個新的產品包項目。注：物料BOM =比爾
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42,Serial No is mandatory for Item {0},項目{0}的序列號是強制性的
-DocType: Item Variant Attribute,Attribute,屬性
-DocType: Staffing Plan Detail,Current Count,當前計數
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43,Please specify from/to range,請從指定/至範圍
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28,Opening {0} Invoice created,打開{0}已創建發票
-DocType: Serial No,Under AMC,在AMC
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55,Item valuation rate is recalculated considering landed cost voucher amount,物品估價率重新計算考慮到岸成本憑證金額
-apps/erpnext/erpnext/config/selling.py +153,Default settings for selling transactions.,銷售交易的預設設定。
-DocType: Guardian,Guardian Of ,守護者
-DocType: Grading Scale Interval,Threshold,閾
-DocType: BOM Update Tool,Current BOM,當前BOM表
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +32,Balance (Dr - Cr),平衡（Dr  -  Cr）
-apps/erpnext/erpnext/public/js/utils.js +56,Add Serial No,添加序列號
-DocType: Work Order Item,Available Qty at Source Warehouse,源倉庫可用數量
-apps/erpnext/erpnext/config/support.py +22,Warranty,保證
-DocType: Purchase Invoice,Debit Note Issued,借記發行說明
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +60,Filter based on Cost Center is only applicable if Budget Against is selected as Cost Center,基於成本中心的過濾僅適用於選擇Budget Against作為成本中心的情況
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1182,"Search by item code, serial number, batch no or barcode",按項目代碼，序列號，批號或條碼進行搜索
-DocType: Work Order,Warehouses,倉庫
-apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +19,{0} asset cannot be transferred,{0}資產不得轉讓
-DocType: Hotel Room Pricing,Hotel Room Pricing,酒店房間價格
-apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py +121,"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}",無法標記出院的住院病歷，有未開單的發票{0}
-apps/erpnext/erpnext/stock/doctype/item/item.js +82,This Item is a Variant of {0} (Template).,此項目是{0}（模板）的變體。
-DocType: Workstation,per hour,每小時
-DocType: Blanket Order,Purchasing,購買
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +139,Customer LPO,客戶LPO
-DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",對於基於批次的學生組，學生批次將由課程註冊中的每位學生進行驗證。
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +51,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,這個倉庫不能被刪除，因為庫存分錄帳尚存在。
-DocType: Journal Entry Account,Loan,貸款
-DocType: Expense Claim Advance,Expense Claim Advance,費用索賠預付款
-DocType: Lab Test,Report Preference,報告偏好
-apps/erpnext/erpnext/config/non_profit.py +43,Volunteer information.,志願者信息。
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +96,Project Manager,專案經理
-,Quoted Item Comparison,項目報價比較
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34,Overlap in scoring between {0} and {1},{0}和{1}之間的得分重疊
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +387,Dispatch,調度
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +75,Max discount allowed for item: {0} is {1}%,{0}允許的最大折扣：{1}％
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +191,Net Asset value as on,淨資產值作為
-DocType: Crop,Produce,生產
-DocType: Hotel Settings,Default Taxes and Charges,默認稅費
-DocType: Account,Receivable,應收帳款
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +325,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,行＃{0}：不能更改供應商的採購訂單已經存在
-DocType: Stock Entry,Material Consumption for Manufacture,材料消耗製造
-DocType: Item Alternative,Alternative Item Code,替代項目代碼
-DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,此角色是允許提交超過所設定信用額度的交易。
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1068,Select Items to Manufacture,選擇項目，以製造
-DocType: Delivery Stop,Delivery Stop,交貨停止
-apps/erpnext/erpnext/accounts/page/pos/pos.js +974,"Master data syncing, it might take some time",主數據同步，這可能需要一些時間
-DocType: Item,Material Issue,發料
-DocType: Employee Education,Qualification,合格
-DocType: Item Price,Item Price,商品價格
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48,Soap & Detergent,肥皂和洗滌劑
-DocType: BOM,Show Items,顯示項目
-apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,從時間不能超過結束時間大。
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +125,Do you want to notify all the customers by email?,你想通過電子郵件通知所有的客戶？
-DocType: Subscription Plan,Billing Interval,計費間隔
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36,Motion Picture & Video,電影和視頻
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,已訂購
-apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py +76,Actual start date and actual end date is mandatory,實際開始日期和實際結束日期是強制性的
-DocType: Salary Detail,Component,零件
-apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +16,Row {0}: {1} must be greater than 0,行{0}：{1}必須大於0
-DocType: Assessment Criteria,Assessment Criteria Group,評估標準組
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +224,Accrual Journal Entry for salaries from {0} to {1},從{0}到{1}的薪金的應計日記帳分錄
-DocType: Sales Invoice Item,Enable Deferred Revenue,啟用延期收入
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +202,Opening Accumulated Depreciation must be less than equal to {0},打開累計折舊必須小於等於{0}
-DocType: Warehouse,Warehouse Name,倉庫名稱
-apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py +20,Actual start date must be less than actual end date,實際開始日期必須小於實際結束日期
-DocType: Naming Series,Select Transaction,選擇交易
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,請輸入核准角色或審批用戶
-DocType: Journal Entry,Write Off Entry,核銷進入
-DocType: BOM,Rate Of Materials Based On,材料成本基於
-DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.",如果啟用，則在學期註冊工具中，字段學術期限將是強制性的。
-apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,支援分析
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +103,Uncheck all,取消所有
-DocType: POS Profile,Terms and Conditions,條款和條件
-DocType: Asset,Booked Fixed Asset,預訂的固定資產
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49,To Date should be within the Fiscal Year. Assuming To Date = {0},日期應該是在財政年度內。假設終止日期= {0}
-DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc",在這裡，你可以保持身高，體重，過敏，醫療問題等
-DocType: Leave Block List,Applies to Company,適用於公司
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +222,Cannot cancel because submitted Stock Entry {0} exists,不能取消，因為提交庫存輸入{0}存在
-DocType: BOM Update Tool,Update latest price in all BOMs,更新所有BOM的最新價格
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +24,Medical Record,醫療記錄
-DocType: Vehicle,Vehicle,車輛
-DocType: Purchase Invoice,In Words,大寫
-apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py +21,Enter the name of the bank or lending institution before submittting.,在提交之前輸入銀行或貸款機構的名稱。
-apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15,{0} must be submitted,必須提交{0}
-DocType: POS Profile,Item Groups,項目組
-DocType: Sales Order Item,For Production,對於生產
-DocType: Payment Request,payment_url,payment_url
-DocType: Exchange Rate Revaluation Account,Balance In Account Currency,科目貨幣餘額
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +188,Please add a Temporary Opening account in Chart of Accounts,請在會計科目表中添加一個臨時開戶科目
-DocType: Customer,Customer Primary Contact,客戶主要聯繫人
-DocType: Project Task,View Task,查看任務
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Opp / Lead％
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Opp / Lead％
-DocType: Bank Guarantee,Bank Account Info,銀行科目信息
-DocType: Bank Guarantee,Bank Guarantee Type,銀行擔保類型
-DocType: Payment Schedule,Invoice Portion,發票部分
-,Asset Depreciations and Balances,資產折舊和平衡
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +372,Amount {0} {1} transferred from {2} to {3},金額{0} {1}從轉移{2}到{3}
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +200,{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0}沒有醫療從業者時間表。將其添加到Healthcare Practitioner master中
-DocType: Sales Invoice,Get Advances Received,取得預先付款
-DocType: Email Digest,Add/Remove Recipients,添加／刪除收件人
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'",要設定這個財政年度為預設值，點擊“設為預設”
-apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py +130,Amount of TDS Deducted,扣除TDS的金額
-DocType: Production Plan,Include Subcontracted Items,包括轉包物料
-apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +81,Shortage Qty,短缺數量
-apps/erpnext/erpnext/stock/doctype/item/item.py +792,Item variant {0} exists with same attributes,項目變種{0}存在具有相同屬性
-DocType: Loan,Repay from Salary,從工資償還
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +405,Requesting payment against {0} {1} for amount {2},請求對付款{0} {1}量{2}
-DocType: Additional Salary,Salary Slip,工資單
-DocType: Lead,Lost Quotation,遺失報價
-apps/erpnext/erpnext/utilities/user_progress.py +221,Student Batches,學生批
-DocType: Pricing Rule,Margin Rate or Amount,保證金稅率或稅額
-apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48,'To Date' is required,“至日期”是必需填寫的
-DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.",產生交貨的包裝單。用於通知箱號，內容及重量。
-apps/erpnext/erpnext/projects/doctype/project/project.py +90,Task weight cannot be negative,任務權重不能為負
-DocType: Sales Invoice Item,Sales Order Item,銷售訂單項目
-DocType: Salary Slip,Payment Days,付款日
-DocType: Stock Settings,Convert Item Description to Clean HTML,將項目描述轉換為清理HTML
-DocType: Payroll Entry,Deduct Tax For Unclaimed Employee Benefits,扣除未領取僱員福利的稅
-DocType: Salary Slip,Total Interest Amount,利息總額
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +125,Warehouses with child nodes cannot be converted to ledger,與子節點倉庫不能轉換為分類賬
-DocType: BOM,Manage cost of operations,管理作業成本
-DocType: Accounts Settings,Stale Days,陳舊的日子
-DocType: Travel Itinerary,Arrival Datetime,到達日期時間
-DocType: Notification Control,"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.",當任何選取的交易都是“已提交”時，郵件會自動自動打開，發送電子郵件到相關的“聯絡人”通知相關交易，並用該交易作為附件。用戶可決定是否發送電子郵件。
-DocType: Tax Rule,Billing Zipcode,計費郵編
-apps/erpnext/erpnext/config/setup.py +14,Global Settings,全局設置
-DocType: Assessment Result Detail,Assessment Result Detail,評價結果詳細
-DocType: Employee Education,Employee Education,員工教育
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53,Duplicate item group found in the item group table,在項目組表中找到重複的項目組
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1247,It is needed to fetch Item Details.,需要獲取項目細節。
-DocType: Fertilizer,Fertilizer Name,肥料名稱
-DocType: Salary Slip,Net Pay,淨收費
-DocType: Cash Flow Mapping Accounts,Account,帳戶
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222,Serial No {0} has already been received,已收到序號{0}
-,Requested Items To Be Transferred,將要轉倉的需求項目
-DocType: Expense Claim,Vehicle Log,車輛登錄
-DocType: Budget,Action if Accumulated Monthly Budget Exceeded on Actual,累計每月預算超出實際的行動
-DocType: Salary Component,Create Separate Payment Entry Against Benefit Claim,針對福利申請創建單獨的付款條目
-DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),發燒（溫度&gt; 38.5°C / 101.3°F或持續溫度&gt; 38°C / 100.4°F）
-DocType: Customer,Sales Team Details,銷售團隊詳細
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1366,Delete permanently?,永久刪除？
-DocType: Expense Claim,Total Claimed Amount,總索賠額
-apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,潛在的銷售機會。
-DocType: Shareholder,Folio no.,Folio no。
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +251,Invalid {0},無效的{0}
-DocType: Email Digest,Email Digest,電子郵件摘要
-DocType: Delivery Note,Billing Address Name,帳單地址名稱
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22,Department Stores,百貨
-,Item Delivery Date,物品交貨日期
-DocType: Selling Settings,Sales Update Frequency,銷售更新頻率
-DocType: Production Plan,Material Requested,要求的材料
-DocType: Warehouse,PIN,銷
-DocType: Bin,Reserved Qty for sub contract,分包合同的保留數量
-DocType: Patient Service Unit,Patinet Service Unit,Patinet服務單位
-DocType: Sales Invoice,Base Change Amount (Company Currency),基地漲跌額（公司幣種）
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +310,No accounting entries for the following warehouses,沒有以下的倉庫會計分錄
-apps/erpnext/erpnext/projects/doctype/project/project.js +98,Save the document first.,首先保存文檔。
-apps/erpnext/erpnext/shopping_cart/cart.py +74,Only {0} in stock for item {1},物品{1}的庫存僅為{0}
-DocType: Account,Chargeable,收費
-DocType: Company,Change Abbreviation,更改縮寫
-DocType: Contract,Fulfilment Details,履行細節
-DocType: Employee Onboarding,Activities,活動
-DocType: Expense Claim Detail,Expense Date,犧牲日期
-DocType: Item,No of Months,沒有幾個月
-DocType: Item,Max Discount (%),最大折讓（％）
-apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30,Credit Days cannot be a negative number,信用日不能是負數
-DocType: Purchase Invoice Item,Service Stop Date,服務停止日期
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,最後訂單金額
-DocType: Cash Flow Mapper,e.g Adjustments for:,例如調整：
-apps/erpnext/erpnext/stock/doctype/item/item.py +304," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} 留樣品是基於批次, 請檢查是否有批次不保留專案的樣品"
-DocType: Certification Application,Yet to appear,尚未出現
-DocType: Delivery Stop,Email Sent To,電子郵件發送給
-DocType: Job Card Item,Job Card Item,工作卡項目
-DocType: Accounts Settings,Allow Cost Center In Entry of Balance Sheet Account,允許成本中心輸入資產負債表科目
-apps/erpnext/erpnext/accounts/doctype/account/account.js +102,Merge with Existing Account,與現有科目合併
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +992,All items have already been transferred for this Work Order.,所有項目已經為此工作單轉移。
-DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.",任何其他言論，值得一提的努力，應該在記錄中。
-DocType: Asset Maintenance,Manufacturing User,製造業用戶
-DocType: Purchase Invoice,Raw Materials Supplied,提供供應商原物料
-DocType: Subscription Plan,Payment Plan,付款計劃
-DocType: Shopping Cart Settings,Enable purchase of items via the website,通過網站啟用購買項目
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +296,Currency of the price list {0} must be {1} or {2},價目表{0}的貨幣必須是{1}或{2}
-apps/erpnext/erpnext/config/accounts.py +561,Subscription Management,訂閱管理
-DocType: Appraisal,Appraisal Template,評估模板
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +255,To Pin Code,要密碼
-DocType: Soil Texture,Ternary Plot,三元劇情
-DocType: Amazon MWS Settings,Check this to enable a scheduled Daily synchronization routine via scheduler,選中此選項可通過調度程序啟用計劃的每日同步例程
-DocType: Item Group,Item Classification,項目分類
-DocType: Driver,License Number,許可證號
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +94,Business Development Manager,業務發展經理
-DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,維護訪問目的
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19,Invoice Patient Registration,發票患者登記
-DocType: Crop,Period,期間
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +27,General Ledger,總帳
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +16,To Fiscal Year,到財政年度
-apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,查看訊息
-DocType: Item Attribute Value,Attribute Value,屬性值
-DocType: POS Closing Voucher Details,Expected Amount,預期金額
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js +16,Create Multiple,創建多個
-,Itemwise Recommended Reorder Level,Itemwise推薦級別重新排序
-apps/erpnext/erpnext/hr/utils.py +212,Employee {0} of grade {1} have no default leave policy,{1}級員工{0}沒有默認離開政策
-DocType: Salary Detail,Salary Detail,薪酬詳細
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1103,Please select {0} first,請先選擇{0}
-apps/erpnext/erpnext/public/js/hub/marketplace.js +176,Added {0} users,添加了{0}個用戶
-apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +21,"In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent",在多層程序的情況下，客戶將根據其花費自動分配到相關層
-DocType: Appointment Type,Physician,醫師
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1076,Batch {0} of Item {1} has expired.,一批項目的{0} {1}已過期。
-apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +56,"Item Price appears multiple times based on Price List, Supplier/Customer, Currency, Item, UOM, Qty and Dates.",物料價格根據價格表，供應商/客戶，貨幣，物料，UOM，數量和日期多次出現。
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +203,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0}（{1}）不能大於計畫數量 {3} 在工作訂單中（{2}）
-DocType: Certification Application,Name of Applicant,申請人名稱
-apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,時間表製造。
-apps/erpnext/erpnext/templates/pages/cart.html +37,Subtotal,小計
-apps/erpnext/erpnext/stock/doctype/item/item.py +731,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,庫存交易後不能更改Variant屬性。你將不得不做一個新的項目來做到這一點。
-apps/erpnext/erpnext/config/integrations.py +18,GoCardless SEPA Mandate,GoCardless SEPA授權
-DocType: Healthcare Practitioner,Charges,收費
-DocType: Production Plan,Get Items For Work Order,獲取工作訂單的物品
-DocType: Salary Detail,Default Amount,預設數量
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +96,Warehouse not found in the system,倉庫系統中未找到
-DocType: Quality Inspection Reading,Quality Inspection Reading,質量檢驗閱讀
-apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +26,`Freeze Stocks Older Than` should be smaller than %d days.,`凍結庫存早於`應該是少於％d天。
-DocType: Tax Rule,Purchase Tax Template,購置稅模板
-apps/erpnext/erpnext/utilities/user_progress.py +48,Set a sales goal you'd like to achieve for your company.,為您的公司設定您想要實現的銷售目標。
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1553,Healthcare Services,醫療服務
-,Project wise Stock Tracking,項目明智的庫存跟踪
-DocType: GST HSN Code,Regional,區域性
-apps/erpnext/erpnext/config/healthcare.py +50,Laboratory,實驗室
-DocType: UOM Category,UOM Category,UOM類別
-DocType: Clinical Procedure Item,Actual Qty (at source/target),實際的數量（於 來源/目標）
-DocType: Item Customer Detail,Ref Code,參考代碼
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75,Customer Group is Required in POS Profile,POS Profile中需要客戶組
-DocType: HR Settings,Payroll Settings,薪資設置
-apps/erpnext/erpnext/config/accounts.py +142,Match non-linked Invoices and Payments.,核對非關聯的發票和付款。
-DocType: POS Settings,POS Settings,POS設置
-apps/erpnext/erpnext/templates/pages/cart.html +16,Place Order,下單
-DocType: Email Digest,New Purchase Orders,新的採購訂單
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +26,Root cannot have a parent cost center,root不能有一個父成本中心
-apps/erpnext/erpnext/public/js/stock_analytics.js +54,Select Brand...,選擇品牌...
-apps/erpnext/erpnext/public/js/setup_wizard.js +32,Non Profit (beta),非營利（測試版）
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +167,Accumulated Depreciation as on,作為累計折舊
-DocType: Employee Tax Exemption Category,Employee Tax Exemption Category,員工免稅類別
-DocType: Sales Invoice,C-Form Applicable,C-表格適用
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +419,Operation Time must be greater than 0 for Operation {0},運行時間必須大於0的操作{0}
-DocType: Support Search Source,Post Route String,郵政路線字符串
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +105,Warehouse is mandatory,倉庫是強制性的
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +72,Failed to create website,無法創建網站
-DocType: Soil Analysis,Mg/K,鎂/ K
-DocType: UOM Conversion Detail,UOM Conversion Detail,計量單位換算詳細
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +989,Retention Stock Entry already created or Sample Quantity not provided,已創建保留庫存條目或未提供“樣本數量”
-DocType: Program,Program Abbreviation,計劃縮寫
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +407,Production Order cannot be raised against a Item Template,生產訂單不能對一個項目提出的模板
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52,Charges are updated in Purchase Receipt against each item,費用對在採購入庫單內的每個項目更新
-DocType: Warranty Claim,Resolved By,議決
-apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js +32,Schedule Discharge,附表卸貨
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,支票及存款不正確清除
-apps/erpnext/erpnext/accounts/doctype/account/account.py +53,Account {0}: You can not assign itself as parent account,科目{0}：你不能指定自己為上層科目
-DocType: Purchase Invoice Item,Price List Rate,價格列表費率
-apps/erpnext/erpnext/utilities/activation.py +72,Create customer quotes,創建客戶報價
-apps/erpnext/erpnext/public/js/controllers/transaction.js +885,Service Stop Date cannot be after Service End Date,服務停止日期不能在服務結束日期之後
-DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",基於倉庫內存貨的狀態顯示「有或」或「無貨」。
-apps/erpnext/erpnext/config/manufacturing.py +38,Bill of Materials (BOM),材料清單（BOM）
-DocType: Item,Average time taken by the supplier to deliver,採取供應商的平均時間交付
-apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +25,Assessment Result,評價結果
-DocType: Employee Transfer,Employee Transfer,員工轉移
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,小時
-DocType: Project,Expected Start Date,預計開始日期
-DocType: Purchase Invoice,04-Correction in Invoice,04-發票糾正
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1041,Work Order already created for all items with BOM,已經為包含物料清單的所有料品創建工單
-DocType: Payment Request,Party Details,黨詳細
-apps/erpnext/erpnext/stock/doctype/item/item.js +62,Variant Details Report,變體詳細信息報告
-DocType: Setup Progress Action,Setup Progress Action,設置進度動作
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +48,Buying Price List,買價格表
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49,Remove item if charges is not applicable to that item,刪除項目，如果收費並不適用於該項目
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +9,Cancel Subscription,取消訂閱
-apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21,Please select Maintenance Status as Completed or remove Completion Date,請選擇維護狀態為已完成或刪除完成日期
-DocType: Supplier,Default Payment Terms Template,默認付款條款模板
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +40,Transaction currency must be same as Payment Gateway currency,交易貨幣必須與支付網關貨幣
-DocType: Payment Entry,Receive,接受
-DocType: Employee Benefit Application Detail,Earning Component,收入組件
-apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,語錄：
-DocType: Contract,Partially Fulfilled,部分實現
-DocType: Maintenance Visit,Fully Completed,全面完成
-apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}％完成
-DocType: Employee,Educational Qualification,學歷
-DocType: Workstation,Operating Costs,運營成本
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +487,Currency for {0} must be {1},貨幣{0}必須{1}
-DocType: Asset,Disposal Date,處置日期
-DocType: Daily Work Summary Settings,"Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.",電子郵件將在指定的時間發送給公司的所有在職職工，如果他們沒有假期。回复摘要將在午夜被發送。
-DocType: Employee Leave Approver,Employee Leave Approver,員工請假審批
-apps/erpnext/erpnext/stock/doctype/item/item.py +541,Row {0}: An Reorder entry already exists for this warehouse {1},行{0}：一個重新排序條目已存在這個倉庫{1}
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99,"Cannot declare as lost, because Quotation has been made.",不能聲明為丟失，因為報價已經取得進展。
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,CWIP Account,CWIP科目
-apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16,Training Feedback,培訓反饋
-apps/erpnext/erpnext/config/accounts.py +184,Tax Withholding rates to be applied on transactions.,稅收預扣稅率適用於交易。
-DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,供應商記分卡標準
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149,Please select Start Date and End Date for Item {0},請選擇項目{0}的開始日期和結束日期
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},當然是行強制性{0}
-apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,無效的主名稱
-DocType: Supplier Quotation Item,Prevdoc DocType,Prevdoc的DocType
-DocType: Cash Flow Mapper,Section Footer,章節頁腳
-apps/erpnext/erpnext/stock/doctype/item/item.js +359,Add / Edit Prices,新增 / 編輯價格
-apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py +19,Employee Promotion cannot be submitted before Promotion Date ,員工晉升不能在晉升日期前提交
-DocType: Salary Component,Is Flexible Benefit,是靈活的好處
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +85,Chart of Cost Centers,成本中心的圖
-DocType: Subscription Settings,Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,在取消訂閱或將訂閱標記為未付之前，發票日期之後的天數已過
-DocType: Clinical Procedure Template,Sample Collection,樣品收集
-,Requested Items To Be Ordered,將要採購的需求項目
-DocType: Price List,Price List Name,價格列表名稱
-DocType: Delivery Stop,Dispatch Information,發貨信息
-DocType: Blanket Order,Manufacturing,製造
-,Ordered Items To Be Delivered,未交貨的訂購項目
-DocType: Account,Income,收入
-DocType: Industry Type,Industry Type,行業類型
-apps/erpnext/erpnext/templates/includes/cart.js +150,Something went wrong!,出事了！
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +174,Warning: Leave application contains following block dates,警告：離開包含以下日期區塊的應用程式
-DocType: Bank Statement Settings,Transaction Data Mapping,交易數據映射
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +280,Sales Invoice {0} has already been submitted,銷售發票{0}已提交
-DocType: Salary Component,Is Tax Applicable,是否適用稅務？
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,會計年度{0}不存在
-DocType: Purchase Invoice Item,Amount (Company Currency),金額（公司貨幣）
-DocType: Agriculture Analysis Criteria,Agriculture User,農業用戶
-apps/erpnext/erpnext/stock/stock_ledger.py +386,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} {1}在需要{2}在{3} {4}：{5}來完成這一交易單位。
-DocType: Fee Schedule,Student Category,學生組
-DocType: Announcement,Student,學生
-apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js +98,Stock quantity to start procedure is not available in the warehouse. Do you want to record a Stock Transfer,倉庫中不提供開始操作的庫存數量。你想記錄庫存轉移嗎？
-DocType: Shipping Rule,Shipping Rule Type,運輸規則類型
-apps/erpnext/erpnext/utilities/user_progress.py +239,Go to Rooms,去房間
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +259,"Company, Payment Account, From Date and To Date is mandatory",公司，付款帳戶，從日期和日期是強制性的
-DocType: Company,Budget Detail,預算案詳情
-apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +79,Please enter message before sending,在發送前，請填寫留言
-DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,供應商重複
-apps/erpnext/erpnext/config/accounts.py +543,Point-of-Sale Profile,簡介銷售點的
-apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +25,{0} should be a value between 0 and 100,{0}應該是0到100之間的一個值
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +323,Payment of {0} from {1} to {2},從{1}到{2}的{0}付款
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166,Unsecured Loans,無抵押貸款
-DocType: Cost Center,Cost Center Name,成本中心名稱
-DocType: HR Settings,Max working hours against Timesheet,最大工作時間針對時間表
-DocType: Maintenance Schedule Detail,Scheduled Date,預定日期
-apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +34,Total Paid Amt,數金額金額
-DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,大於160個字元的訊息將被分割成多個訊息送出
-DocType: Purchase Receipt Item,Received and Accepted,收貨及允收
-,GST Itemised Sales Register,消費稅商品銷售登記冊
-DocType: Staffing Plan,Staffing Plan Details,人員配置計劃詳情
-,Serial No Service Contract Expiry,序號服務合同到期
-DocType: Employee Health Insurance,Employee Health Insurance,員工健康保險
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +331,You cannot credit and debit same account at the same time,你無法將貸方與借方在同一時間記在同一科目
-DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,成年人的脈率在每分鐘50到80次之間。
-DocType: Naming Series,Help HTML,HTML幫助
-DocType: Student Group Creation Tool,Student Group Creation Tool,學生組創建工具
-DocType: Item,Variant Based On,基於變異對
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53,Total weightage assigned should be 100%. It is {0},分配的總權重應為100 ％ 。這是{0}
-DocType: Loyalty Point Entry,Loyalty Program Tier,忠誠度計劃層
-apps/erpnext/erpnext/utilities/user_progress.py +109,Your Suppliers,您的供應商
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80,Cannot set as Lost as Sales Order is made.,不能設置為失落的銷售訂單而成。
-DocType: Request for Quotation Item,Supplier Part No,供應商部件號
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +395,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',當類是“估值”或“Vaulation和總&#39;不能扣除
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +379,Received From,從......收到
-DocType: Lead,Converted,轉換
-DocType: Item,Has Serial No,有序列號
-DocType: Employee,Date of Issue,發行日期
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +252,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}",根據購買設置，如果需要購買記錄==“是”，則為了創建採購發票，用戶需要首先為項目{0}創建採購憑證
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +173,Row #{0}: Set Supplier for item {1},行＃{0}：設置供應商項目{1}
-DocType: Global Defaults,Default Distance Unit,默認距離單位
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127,Row {0}: Hours value must be greater than zero.,行{0}：小時值必須大於零。
-apps/erpnext/erpnext/stock/doctype/item/item.py +224,Website Image {0} attached to Item {1} cannot be found,網站圖像{0}附加到物品{1}無法找到
-DocType: Issue,Content Type,內容類型
-DocType: Asset,Assets,資產
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17,Computer,電腦
-DocType: Item,List this Item in multiple groups on the website.,列出這個項目在網站上多個組。
-DocType: Subscription,Current Invoice End Date,當前發票結束日期
-DocType: Payment Term,Due Date Based On,到期日基於
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +82,Please set default customer group and territory in Selling Settings,請在“銷售設置”中設置默認客戶組和領域
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +355,Please check Multi Currency option to allow accounts with other currency,請檢查多幣種選項，允許帳戶與其他貨幣
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +88,Item: {0} does not exist in the system,項：{0}不存在於系統中
-apps/erpnext/erpnext/accounts/doctype/account/account.py +113,You are not authorized to set Frozen value,您無權設定值凍結
-DocType: Payment Reconciliation,Get Unreconciled Entries,獲取未調節項
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,Employee {0} is on Leave on {1},員工{0}暫停{1}
-apps/erpnext/erpnext/hr/doctype/loan/loan.py +159,No repayments selected for Journal Entry,沒有為日記帳分錄選擇還款
-DocType: Payment Reconciliation,From Invoice Date,從發票日期
-DocType: Healthcare Settings,Laboratory Settings,實驗室設置
-DocType: Clinical Procedure,Service Unit,服務單位
-apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97,Successfully Set Supplier,成功設置供應商
-DocType: Leave Encashment,Leave Encashment,離開兌現
-apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,它有什麼作用？
-apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +47,Tasks have been created for managing the {0} disease (on row {1}),為管理{0}疾病創建了任務（在第{1}行）
-DocType: Crop,Byproducts,副產品
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +84,To Warehouse,到倉庫
-apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26,All Student Admissions,所有學生入學
-,Average Commission Rate,平均佣金比率
-DocType: Share Balance,No of Shares,股份數目
-DocType: Taxable Salary Slab,To Amount,金額
-apps/erpnext/erpnext/stock/doctype/item/item.py +479,'Has Serial No' can not be 'Yes' for non-stock item,非庫存項目不能有序號
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +59,Select Status,選擇狀態
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +44,Attendance can not be marked for future dates,考勤不能標記為未來的日期
-DocType: Support Search Source,Post Description Key,發布說明密鑰
-DocType: Pricing Rule,Pricing Rule Help,定價規則說明
-DocType: Fee Schedule,Total Amount per Student,學生總數
-DocType: Opportunity,Sales Stage,銷售階段
-DocType: Purchase Taxes and Charges,Account Head,帳戶頭
-DocType: Company,HRA Component,HRA組件
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119,Electrical,電子的
-apps/erpnext/erpnext/utilities/activation.py +100,Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,添加您的組織的其餘部分用戶。您還可以添加邀請客戶到您的門戶網站通過從聯繫人中添加它們
-DocType: Stock Entry,Total Value Difference (Out - In),總價值差（輸出 - ）
-DocType: Grant Application,Requested Amount,請求金額
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380,Row {0}: Exchange Rate is mandatory,行{0}：匯率是必須的
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +46,User ID not set for Employee {0},用戶ID不為員工設置{0}
-DocType: Vehicle,Vehicle Value,汽車衡
-DocType: Crop Cycle,Detected Diseases,檢測到的疾病
-DocType: Stock Entry,Default Source Warehouse,預設來源倉庫
-DocType: Item,Customer Code,客戶代碼
-DocType: Asset Maintenance Task,Last Completion Date,最後完成日期
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72,Days Since Last Order,天自上次訂購
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +437,Debit To account must be a Balance Sheet account,借方帳戶必須是資產負債表科目
-DocType: Vital Signs,Coated,塗
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +190,Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,行{0}：使用壽命後的預期值必須小於總採購額
-DocType: GoCardless Settings,GoCardless Settings,GoCardless設置
-DocType: Leave Block List,Leave Block List Name,休假區塊清單名稱
-DocType: Certified Consultant,Certification Validity,認證有效性
-apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14,Insurance Start date should be less than Insurance End date,保險開始日期應小於保險終止日期
-DocType: Shopping Cart Settings,Display Settings,顯示設置
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock Assets,庫存資產
-DocType: Restaurant,Active Menu,活動菜單
-DocType: Target Detail,Target Qty,目標數量
-apps/erpnext/erpnext/hr/doctype/loan/loan.py +37,Against Loan: {0},反對貸款：{0}
-DocType: Shopping Cart Settings,Checkout Settings,結帳設定
-DocType: Student Attendance,Present,現在
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,Delivery Note {0} must not be submitted,送貨單{0}不能提交
-DocType: Notification Control,Sales Invoice Message,銷售發票訊息
-apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,關閉科目{0}的類型必須是負債/權益
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +407,Salary Slip of employee {0} already created for time sheet {1},員工的工資單{0}已為時間表創建{1}
-DocType: Production Plan Item,Ordered Qty,訂購數量
-apps/erpnext/erpnext/stock/doctype/item/item.py +822,Item {0} is disabled,項目{0}無效
-DocType: Stock Settings,Stock Frozen Upto,存貨凍結到...為止
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +1021,BOM does not contain any stock item,BOM不包含任何庫存項目
-DocType: Chapter,Chapter Head,章主管
-DocType: Payment Term,Month(s) after the end of the invoice month,發票月份結束後的月份
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +66,Salary Structure should have flexible benefit component(s) to dispense benefit amount,薪酬結構應該有靈活的福利組成來分配福利金額
-apps/erpnext/erpnext/config/projects.py +24,Project activity / task.,專案活動／任務。
-DocType: Vital Signs,Very Coated,非常塗層
-DocType: Salary Component,Only Tax Impact (Cannot Claim But Part of Taxable Income),只有稅收影響（不能索取但應稅收入的一部分）
-DocType: Vehicle Log,Refuelling Details,加油詳情
-apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +25,Lab result datetime cannot be before testing datetime,實驗結果日期時間不能在測試日期時間之前
-DocType: POS Profile,Allow user to edit Discount,允許用戶編輯折扣
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +65,Get customers from,從中獲取客戶
-DocType: Purchase Invoice Item,Include Exploded Items,包含爆炸物品
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +46,"Buying must be checked, if Applicable For is selected as {0}",採購必須進行檢查，如果適用於被選擇為{0}
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,折扣必須小於100
-DocType: Shipping Rule,Restrict to Countries,限製到國家
-DocType: Amazon MWS Settings,Synch Taxes and Charges,同步稅和費用
-DocType: Purchase Invoice,Write Off Amount (Company Currency),核銷金額（公司貨幣）
-DocType: Sales Invoice Timesheet,Billing Hours,結算時間
-DocType: Project,Total Sales Amount (via Sales Order),總銷售額（通過銷售訂單）
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +529,Default BOM for {0} not found,默認BOM {0}未找到
-apps/erpnext/erpnext/stock/doctype/item/item.py +545,Row #{0}: Please set reorder quantity,行＃{0}：請設置再訂購數量
-apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,點擊項目將其添加到此處
-DocType: Fees,Program Enrollment,招生計劃
-DocType: Share Transfer,To Folio No,對開本No
-DocType: Landed Cost Voucher,Landed Cost Voucher,到岸成本憑證
-apps/erpnext/erpnext/public/js/queries.js +39,Please set {0},請設置{0}
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0}  -  {1}是非活動學生
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0}  -  {1}是非活動學生
-DocType: Employee,Health Details,健康細節
-DocType: Leave Encashment,Encashable days,可以忍受的日子
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +30,To create a Payment Request reference document is required,要創建付款請求參考文檔是必需的
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +30,To create a Payment Request reference document is required,要創建付款請求參考文檔是必需的
-DocType: Grant Application,Assessment  Manager,評估經理
-DocType: Payment Entry,Allocate Payment Amount,分配付款金額
-DocType: Subscription Plan,Subscription Plan,訂閱計劃
-DocType: Employee External Work History,Salary,薪水
-DocType: Serial No,Delivery Document Type,交付文件類型
-DocType: Item Variant Settings,Do not update variants on save,不要在保存時更新變體
-DocType: Email Digest,Receivables,應收帳款
-DocType: Lead Source,Lead Source,主導來源
-DocType: Customer,Additional information regarding the customer.,對於客戶的其他訊息。
-DocType: Quality Inspection Reading,Reading 5,閱讀5
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +237,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} 與 {2} 關聯, 但當事方科目為 {3}"
-DocType: Bank Statement Settings Item,Bank Header,銀行標題
-apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7,View Lab Tests,查看實驗室測試
-DocType: Hub Users,Hub Users,Hub用戶
-DocType: Purchase Invoice,Y,ÿ
-DocType: Maintenance Visit,Maintenance Date,維修日期
-DocType: Purchase Invoice Item,Rejected Serial No,拒絕序列號
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82,Year start date or end date is overlapping with {0}. To avoid please set company,新年的開始日期或結束日期與{0}重疊。為了避免請將公司
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +137,Please mention the Lead Name in Lead {0},請提及潛在客戶名稱{0}
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156,Start date should be less than end date for Item {0},項目{0}的開始日期必須小於結束日期
-DocType: Item,"Example: ABCD.#####
+Serial No is mandatory for Item {0},項目{0}的序列號是強制性的
+Attribute,屬性
+Current Count,當前計數
+Please specify from/to range,請從指定/至範圍
+Opening {0} Invoice created,打開{0}已創建發票
+Under AMC,在AMC,
+Item valuation rate is recalculated considering landed cost voucher amount,物品估價率重新計算考慮到岸成本憑證金額
+Default settings for selling transactions.,銷售交易的預設設定。
+Guardian Of ,守護者
+Threshold,閾
+Current BOM,當前BOM表
+Balance (Dr - Cr),平衡（Dr  -  Cr）
+Add Serial No,添加序列號
+Available Qty at Source Warehouse,源倉庫可用數量
+Warranty,保證
+Debit Note Issued,借記發行說明
+Filter based on Cost Center is only applicable if Budget Against is selected as Cost Center,基於成本中心的過濾僅適用於選擇Budget Against作為成本中心的情況
+"Search by item code, serial number, batch no or barcode",按項目代碼，序列號，批號或條碼進行搜索
+Warehouses,倉庫
+{0} asset cannot be transferred,{0}資產不得轉讓
+Hotel Room Pricing,酒店房間價格
+"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}",無法標記出院的住院病歷，有未開單的發票{0}
+This Item is a Variant of {0} (Template).,此項目是{0}（模板）的變體。
+per hour,每小時
+Purchasing,購買
+Customer LPO,客戶LPO,
+"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",對於基於批次的學生組，學生批次將由課程註冊中的每位學生進行驗證。
+Warehouse can not be deleted as stock ledger entry exists for this warehouse.,這個倉庫不能被刪除，因為庫存分錄帳尚存在。
+Loan,貸款
+Expense Claim Advance,費用索賠預付款
+Report Preference,報告偏好
+Volunteer information.,志願者信息。
+Project Manager,專案經理
+Quoted Item Comparison,項目報價比較
+Overlap in scoring between {0} and {1},{0}和{1}之間的得分重疊
+Dispatch,調度
+Max discount allowed for item: {0} is {1}%,{0}允許的最大折扣：{1}％
+Net Asset value as on,淨資產值作為
+Produce,生產
+Default Taxes and Charges,默認稅費
+Receivable,應收帳款
+Row #{0}: Not allowed to change Supplier as Purchase Order already exists,行＃{0}：不能更改供應商的採購訂單已經存在
+Material Consumption for Manufacture,材料消耗製造
+Alternative Item Code,替代項目代碼
+Role that is allowed to submit transactions that exceed credit limits set.,此角色是允許提交超過所設定信用額度的交易。
+Select Items to Manufacture,選擇項目，以製造
+Delivery Stop,交貨停止
+"Master data syncing, it might take some time",主數據同步，這可能需要一些時間
+Material Issue,發料
+Qualification,合格
+Item Price,商品價格
+Soap & Detergent,肥皂和洗滌劑
+Show Items,顯示項目
+From Time cannot be greater than To Time.,從時間不能超過結束時間大。
+Do you want to notify all the customers by email?,你想通過電子郵件通知所有的客戶？
+Billing Interval,計費間隔
+Motion Picture & Video,電影和視頻
+Ordered,已訂購
+Actual start date and actual end date is mandatory,實際開始日期和實際結束日期是強制性的
+Component,零件
+Row {0}: {1} must be greater than 0,行{0}：{1}必須大於0,
+Assessment Criteria Group,評估標準組
+Accrual Journal Entry for salaries from {0} to {1},從{0}到{1}的薪金的應計日記帳分錄
+Enable Deferred Revenue,啟用延期收入
+Opening Accumulated Depreciation must be less than equal to {0},打開累計折舊必須小於等於{0}
+Warehouse Name,倉庫名稱
+Actual start date must be less than actual end date,實際開始日期必須小於實際結束日期
+Select Transaction,選擇交易
+Please enter Approving Role or Approving User,請輸入核准角色或審批用戶
+Write Off Entry,核銷進入
+Rate Of Materials Based On,材料成本基於
+"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.",如果啟用，則在學期註冊工具中，字段學術期限將是強制性的。
+Support Analtyics,支援分析
+Uncheck all,取消所有
+Terms and Conditions,條款和條件
+Booked Fixed Asset,預訂的固定資產
+To Date should be within the Fiscal Year. Assuming To Date = {0},日期應該是在財政年度內。假設終止日期= {0}
+"Here you can maintain height, weight, allergies, medical concerns etc",在這裡，你可以保持身高，體重，過敏，醫療問題等
+Applies to Company,適用於公司
+Cannot cancel because submitted Stock Entry {0} exists,不能取消，因為提交庫存輸入{0}存在
+Update latest price in all BOMs,更新所有BOM的最新價格
+Medical Record,醫療記錄
+Vehicle,車輛
+In Words,大寫
+Enter the name of the bank or lending institution before submittting.,在提交之前輸入銀行或貸款機構的名稱。
+{0} must be submitted,必須提交{0}
+Item Groups,項目組
+For Production,對於生產
+payment_url,payment_url,
+Balance In Account Currency,科目貨幣餘額
+Please add a Temporary Opening account in Chart of Accounts,請在會計科目表中添加一個臨時開戶科目
+Customer Primary Contact,客戶主要聯繫人
+View Task,查看任務
+Opp/Lead %,Opp / Lead％
+Opp/Lead %,Opp / Lead％
+Bank Account Info,銀行科目信息
+Bank Guarantee Type,銀行擔保類型
+Invoice Portion,發票部分
+Asset Depreciations and Balances,資產折舊和平衡
+Amount {0} {1} transferred from {2} to {3},金額{0} {1}從轉移{2}到{3}
+{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0}沒有醫療從業者時間表。將其添加到Healthcare Practitioner master中
+Get Advances Received,取得預先付款
+Add/Remove Recipients,添加／刪除收件人
+"To set this Fiscal Year as Default, click on 'Set as Default'",要設定這個財政年度為預設值，點擊“設為預設”
+Amount of TDS Deducted,扣除TDS的金額
+Include Subcontracted Items,包括轉包物料
+Shortage Qty,短缺數量
+Item variant {0} exists with same attributes,項目變種{0}存在具有相同屬性
+Repay from Salary,從工資償還
+Requesting payment against {0} {1} for amount {2},請求對付款{0} {1}量{2}
+Salary Slip,工資單
+Lost Quotation,遺失報價
+Student Batches,學生批
+Margin Rate or Amount,保證金稅率或稅額
+'To Date' is required,“至日期”是必需填寫的
+"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.",產生交貨的包裝單。用於通知箱號，內容及重量。
+Task weight cannot be negative,任務權重不能為負
+Sales Order Item,銷售訂單項目
+Payment Days,付款日
+Convert Item Description to Clean HTML,將項目描述轉換為清理HTML,
+Deduct Tax For Unclaimed Employee Benefits,扣除未領取僱員福利的稅
+Total Interest Amount,利息總額
+Warehouses with child nodes cannot be converted to ledger,與子節點倉庫不能轉換為分類賬
+Manage cost of operations,管理作業成本
+Stale Days,陳舊的日子
+Arrival Datetime,到達日期時間
+"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.",當任何選取的交易都是“已提交”時，郵件會自動自動打開，發送電子郵件到相關的“聯絡人”通知相關交易，並用該交易作為附件。用戶可決定是否發送電子郵件。
+Billing Zipcode,計費郵編
+Global Settings,全局設置
+Assessment Result Detail,評價結果詳細
+Employee Education,員工教育
+Duplicate item group found in the item group table,在項目組表中找到重複的項目組
+It is needed to fetch Item Details.,需要獲取項目細節。
+Fertilizer Name,肥料名稱
+Net Pay,淨收費
+Account,帳戶
+Serial No {0} has already been received,已收到序號{0}
+Requested Items To Be Transferred,將要轉倉的需求項目
+Vehicle Log,車輛登錄
+Action if Accumulated Monthly Budget Exceeded on Actual,累計每月預算超出實際的行動
+Create Separate Payment Entry Against Benefit Claim,針對福利申請創建單獨的付款條目
+Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),發燒（溫度&gt; 38.5°C / 101.3°F或持續溫度&gt; 38°C / 100.4°F）
+Sales Team Details,銷售團隊詳細
+Delete permanently?,永久刪除？
+Total Claimed Amount,總索賠額
+Potential opportunities for selling.,潛在的銷售機會。
+Folio no.,Folio no。
+Invalid {0},無效的{0}
+Email Digest,電子郵件摘要
+Billing Address Name,帳單地址名稱
+Department Stores,百貨
+Item Delivery Date,物品交貨日期
+Sales Update Frequency,銷售更新頻率
+Material Requested,要求的材料
+PIN,銷
+Reserved Qty for sub contract,分包合同的保留數量
+Patinet Service Unit,Patinet服務單位
+Base Change Amount (Company Currency),基地漲跌額（公司幣種）
+No accounting entries for the following warehouses,沒有以下的倉庫會計分錄
+Save the document first.,首先保存文檔。
+Only {0} in stock for item {1},物品{1}的庫存僅為{0}
+Chargeable,收費
+Change Abbreviation,更改縮寫
+Fulfilment Details,履行細節
+Activities,活動
+Expense Date,犧牲日期
+No of Months,沒有幾個月
+Max Discount (%),最大折讓（％）
+Credit Days cannot be a negative number,信用日不能是負數
+Service Stop Date,服務停止日期
+Last Order Amount,最後訂單金額
+e.g Adjustments for:,例如調整：
+" {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} 留樣品是基於批次, 請檢查是否有批次不保留專案的樣品"
+Yet to appear,尚未出現
+Email Sent To,電子郵件發送給
+Job Card Item,工作卡項目
+Allow Cost Center In Entry of Balance Sheet Account,允許成本中心輸入資產負債表科目
+Merge with Existing Account,與現有科目合併
+All items have already been transferred for this Work Order.,所有項目已經為此工作單轉移。
+"Any other remarks, noteworthy effort that should go in the records.",任何其他言論，值得一提的努力，應該在記錄中。
+Manufacturing User,製造業用戶
+Raw Materials Supplied,提供供應商原物料
+Payment Plan,付款計劃
+Enable purchase of items via the website,通過網站啟用購買項目
+Currency of the price list {0} must be {1} or {2},價目表{0}的貨幣必須是{1}或{2}
+Subscription Management,訂閱管理
+Appraisal Template,評估模板
+To Pin Code,要密碼
+Ternary Plot,三元劇情
+Check this to enable a scheduled Daily synchronization routine via scheduler,選中此選項可通過調度程序啟用計劃的每日同步例程
+Item Classification,項目分類
+License Number,許可證號
+Business Development Manager,業務發展經理
+Maintenance Visit Purpose,維護訪問目的
+Invoice Patient Registration,發票患者登記
+Period,期間
+General Ledger,總帳
+To Fiscal Year,到財政年度
+View Leads,查看訊息
+Attribute Value,屬性值
+Expected Amount,預期金額
+Create Multiple,創建多個
+Itemwise Recommended Reorder Level,Itemwise推薦級別重新排序
+Employee {0} of grade {1} have no default leave policy,{1}級員工{0}沒有默認離開政策
+Salary Detail,薪酬詳細
+Please select {0} first,請先選擇{0}
+Added {0} users,添加了{0}個用戶
+"In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent",在多層程序的情況下，客戶將根據其花費自動分配到相關層
+Physician,醫師
+Batch {0} of Item {1} has expired.,一批項目的{0} {1}已過期。
+"Item Price appears multiple times based on Price List, Supplier/Customer, Currency, Item, UOM, Qty and Dates.",物料價格根據價格表，供應商/客戶，貨幣，物料，UOM，數量和日期多次出現。
+{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0}（{1}）不能大於計畫數量 {3} 在工作訂單中（{2}）
+Name of Applicant,申請人名稱
+Time Sheet for manufacturing.,時間表製造。
+Subtotal,小計
+Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,庫存交易後不能更改Variant屬性。你將不得不做一個新的項目來做到這一點。
+GoCardless SEPA Mandate,GoCardless SEPA授權
+Charges,收費
+Get Items For Work Order,獲取工作訂單的物品
+Default Amount,預設數量
+Warehouse not found in the system,倉庫系統中未找到
+Quality Inspection Reading,質量檢驗閱讀
+`Freeze Stocks Older Than` should be smaller than %d days.,`凍結庫存早於`應該是少於％d天。
+Purchase Tax Template,購置稅模板
+Set a sales goal you'd like to achieve for your company.,為您的公司設定您想要實現的銷售目標。
+Healthcare Services,醫療服務
+Project wise Stock Tracking,項目明智的庫存跟踪
+Regional,區域性
+Laboratory,實驗室
+UOM Category,UOM類別
+Actual Qty (at source/target),實際的數量（於 來源/目標）
+Ref Code,參考代碼
+Customer Group is Required in POS Profile,POS Profile中需要客戶組
+Payroll Settings,薪資設置
+Match non-linked Invoices and Payments.,核對非關聯的發票和付款。
+POS Settings,POS設置
+Place Order,下單
+New Purchase Orders,新的採購訂單
+Root cannot have a parent cost center,root不能有一個父成本中心
+Select Brand...,選擇品牌...
+Non Profit (beta),非營利（測試版）
+Accumulated Depreciation as on,作為累計折舊
+Employee Tax Exemption Category,員工免稅類別
+C-Form Applicable,C-表格適用
+Operation Time must be greater than 0 for Operation {0},運行時間必須大於0的操作{0}
+Post Route String,郵政路線字符串
+Warehouse is mandatory,倉庫是強制性的
+Failed to create website,無法創建網站
+Mg/K,鎂/ K,
+UOM Conversion Detail,計量單位換算詳細
+Retention Stock Entry already created or Sample Quantity not provided,已創建保留庫存條目或未提供“樣本數量”
+Program Abbreviation,計劃縮寫
+Production Order cannot be raised against a Item Template,生產訂單不能對一個項目提出的模板
+Charges are updated in Purchase Receipt against each item,費用對在採購入庫單內的每個項目更新
+Resolved By,議決
+Schedule Discharge,附表卸貨
+Cheques and Deposits incorrectly cleared,支票及存款不正確清除
+Account {0}: You can not assign itself as parent account,科目{0}：你不能指定自己為上層科目
+Price List Rate,價格列表費率
+Create customer quotes,創建客戶報價
+Service Stop Date cannot be after Service End Date,服務停止日期不能在服務結束日期之後
+"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",基於倉庫內存貨的狀態顯示「有或」或「無貨」。
+Bill of Materials (BOM),材料清單（BOM）
+Average time taken by the supplier to deliver,採取供應商的平均時間交付
+Assessment Result,評價結果
+Employee Transfer,員工轉移
+Hours,小時
+Expected Start Date,預計開始日期
+04-Correction in Invoice,04-發票糾正
+Work Order already created for all items with BOM,已經為包含物料清單的所有料品創建工單
+Party Details,黨詳細
+Variant Details Report,變體詳細信息報告
+Setup Progress Action,設置進度動作
+Buying Price List,買價格表
+Remove item if charges is not applicable to that item,刪除項目，如果收費並不適用於該項目
+Cancel Subscription,取消訂閱
+Please select Maintenance Status as Completed or remove Completion Date,請選擇維護狀態為已完成或刪除完成日期
+Default Payment Terms Template,默認付款條款模板
+Transaction currency must be same as Payment Gateway currency,交易貨幣必須與支付網關貨幣
+Receive,接受
+Earning Component,收入組件
+Quotations: ,語錄：
+Partially Fulfilled,部分實現
+Fully Completed,全面完成
+{0}% Complete,{0}％完成
+Educational Qualification,學歷
+Operating Costs,運營成本
+Currency for {0} must be {1},貨幣{0}必須{1}
+Disposal Date,處置日期
+"Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.",電子郵件將在指定的時間發送給公司的所有在職職工，如果他們沒有假期。回复摘要將在午夜被發送。
+Employee Leave Approver,員工請假審批
+Row {0}: An Reorder entry already exists for this warehouse {1},行{0}：一個重新排序條目已存在這個倉庫{1}
+"Cannot declare as lost, because Quotation has been made.",不能聲明為丟失，因為報價已經取得進展。
+CWIP Account,CWIP科目
+Training Feedback,培訓反饋
+Tax Withholding rates to be applied on transactions.,稅收預扣稅率適用於交易。
+Supplier Scorecard Criteria,供應商記分卡標準
+Please select Start Date and End Date for Item {0},請選擇項目{0}的開始日期和結束日期
+Course is mandatory in row {0},當然是行強制性{0}
+To date cannot be before from date,無效的主名稱
+Prevdoc DocType,Prevdoc的DocType,
+Section Footer,章節頁腳
+Add / Edit Prices,新增 / 編輯價格
+Employee Promotion cannot be submitted before Promotion Date ,員工晉升不能在晉升日期前提交
+Is Flexible Benefit,是靈活的好處
+Chart of Cost Centers,成本中心的圖
+Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,在取消訂閱或將訂閱標記為未付之前，發票日期之後的天數已過
+Sample Collection,樣品收集
+Requested Items To Be Ordered,將要採購的需求項目
+Price List Name,價格列表名稱
+Dispatch Information,發貨信息
+Manufacturing,製造
+Ordered Items To Be Delivered,未交貨的訂購項目
+Income,收入
+Industry Type,行業類型
+Something went wrong!,出事了！
+Warning: Leave application contains following block dates,警告：離開包含以下日期區塊的應用程式
+Transaction Data Mapping,交易數據映射
+Sales Invoice {0} has already been submitted,銷售發票{0}已提交
+Is Tax Applicable,是否適用稅務？
+Fiscal Year {0} does not exist,會計年度{0}不存在
+Amount (Company Currency),金額（公司貨幣）
+Agriculture User,農業用戶
+{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} {1}在需要{2}在{3} {4}：{5}來完成這一交易單位。
+Student Category,學生組
+Student,學生
+Stock quantity to start procedure is not available in the warehouse. Do you want to record a Stock Transfer,倉庫中不提供開始操作的庫存數量。你想記錄庫存轉移嗎？
+Shipping Rule Type,運輸規則類型
+Go to Rooms,去房間
+"Company, Payment Account, From Date and To Date is mandatory",公司，付款帳戶，從日期和日期是強制性的
+Budget Detail,預算案詳情
+Please enter message before sending,在發送前，請填寫留言
+DUPLICATE FOR SUPPLIER,供應商重複
+Point-of-Sale Profile,簡介銷售點的
+{0} should be a value between 0 and 100,{0}應該是0到100之間的一個值
+Payment of {0} from {1} to {2},從{1}到{2}的{0}付款
+Unsecured Loans,無抵押貸款
+Cost Center Name,成本中心名稱
+Max working hours against Timesheet,最大工作時間針對時間表
+Scheduled Date,預定日期
+Total Paid Amt,數金額金額
+Messages greater than 160 characters will be split into multiple messages,大於160個字元的訊息將被分割成多個訊息送出
+Received and Accepted,收貨及允收
+GST Itemised Sales Register,消費稅商品銷售登記冊
+Staffing Plan Details,人員配置計劃詳情
+Serial No Service Contract Expiry,序號服務合同到期
+Employee Health Insurance,員工健康保險
+You cannot credit and debit same account at the same time,你無法將貸方與借方在同一時間記在同一科目
+Adults' pulse rate is anywhere between 50 and 80 beats per minute.,成年人的脈率在每分鐘50到80次之間。
+Help HTML,HTML幫助
+Student Group Creation Tool,學生組創建工具
+Variant Based On,基於變異對
+Total weightage assigned should be 100%. It is {0},分配的總權重應為100 ％ 。這是{0}
+Loyalty Program Tier,忠誠度計劃層
+Your Suppliers,您的供應商
+Cannot set as Lost as Sales Order is made.,不能設置為失落的銷售訂單而成。
+Supplier Part No,供應商部件號
+Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',當類是“估值”或“Vaulation和總&#39;不能扣除
+Received From,從......收到
+Converted,轉換
+Has Serial No,有序列號
+Date of Issue,發行日期
+"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}",根據購買設置，如果需要購買記錄==“是”，則為了創建採購發票，用戶需要首先為項目{0}創建採購憑證
+Row #{0}: Set Supplier for item {1},行＃{0}：設置供應商項目{1}
+Default Distance Unit,默認距離單位
+Row {0}: Hours value must be greater than zero.,行{0}：小時值必須大於零。
+Website Image {0} attached to Item {1} cannot be found,網站圖像{0}附加到物品{1}無法找到
+Content Type,內容類型
+Assets,資產
+Computer,電腦
+List this Item in multiple groups on the website.,列出這個項目在網站上多個組。
+Current Invoice End Date,當前發票結束日期
+Due Date Based On,到期日基於
+Please set default customer group and territory in Selling Settings,請在“銷售設置”中設置默認客戶組和領域
+Please check Multi Currency option to allow accounts with other currency,請檢查多幣種選項，允許帳戶與其他貨幣
+Item: {0} does not exist in the system,項：{0}不存在於系統中
+You are not authorized to set Frozen value,您無權設定值凍結
+Get Unreconciled Entries,獲取未調節項
+Employee {0} is on Leave on {1},員工{0}暫停{1}
+No repayments selected for Journal Entry,沒有為日記帳分錄選擇還款
+From Invoice Date,從發票日期
+Laboratory Settings,實驗室設置
+Service Unit,服務單位
+Successfully Set Supplier,成功設置供應商
+Leave Encashment,離開兌現
+What does it do?,它有什麼作用？
+Tasks have been created for managing the {0} disease (on row {1}),為管理{0}疾病創建了任務（在第{1}行）
+Byproducts,副產品
+To Warehouse,到倉庫
+All Student Admissions,所有學生入學
+Average Commission Rate,平均佣金比率
+No of Shares,股份數目
+To Amount,金額
+'Has Serial No' can not be 'Yes' for non-stock item,非庫存項目不能有序號
+Select Status,選擇狀態
+Attendance can not be marked for future dates,考勤不能標記為未來的日期
+Post Description Key,發布說明密鑰
+Pricing Rule Help,定價規則說明
+Total Amount per Student,學生總數
+Sales Stage,銷售階段
+Account Head,帳戶頭
+HRA Component,HRA組件
+Electrical,電子的
+Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,添加您的組織的其餘部分用戶。您還可以添加邀請客戶到您的門戶網站通過從聯繫人中添加它們
+Total Value Difference (Out - In),總價值差（輸出 - ）
+Requested Amount,請求金額
+Row {0}: Exchange Rate is mandatory,行{0}：匯率是必須的
+User ID not set for Employee {0},用戶ID不為員工設置{0}
+Vehicle Value,汽車衡
+Detected Diseases,檢測到的疾病
+Default Source Warehouse,預設來源倉庫
+Customer Code,客戶代碼
+Last Completion Date,最後完成日期
+Days Since Last Order,天自上次訂購
+Debit To account must be a Balance Sheet account,借方帳戶必須是資產負債表科目
+Coated,塗
+Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,行{0}：使用壽命後的預期值必須小於總採購額
+GoCardless Settings,GoCardless設置
+Leave Block List Name,休假區塊清單名稱
+Certification Validity,認證有效性
+Insurance Start date should be less than Insurance End date,保險開始日期應小於保險終止日期
+Display Settings,顯示設置
+Stock Assets,庫存資產
+Active Menu,活動菜單
+Target Qty,目標數量
+Against Loan: {0},反對貸款：{0}
+Checkout Settings,結帳設定
+Present,現在
+Delivery Note {0} must not be submitted,送貨單{0}不能提交
+Sales Invoice Message,銷售發票訊息
+Closing Account {0} must be of type Liability / Equity,關閉科目{0}的類型必須是負債/權益
+Salary Slip of employee {0} already created for time sheet {1},員工的工資單{0}已為時間表創建{1}
+Ordered Qty,訂購數量
+Item {0} is disabled,項目{0}無效
+Stock Frozen Upto,存貨凍結到...為止
+BOM does not contain any stock item,BOM不包含任何庫存項目
+Chapter Head,章主管
+Month(s) after the end of the invoice month,發票月份結束後的月份
+Salary Structure should have flexible benefit component(s) to dispense benefit amount,薪酬結構應該有靈活的福利組成來分配福利金額
+Project activity / task.,專案活動／任務。
+Very Coated,非常塗層
+Only Tax Impact (Cannot Claim But Part of Taxable Income),只有稅收影響（不能索取但應稅收入的一部分）
+Refuelling Details,加油詳情
+Lab result datetime cannot be before testing datetime,實驗結果日期時間不能在測試日期時間之前
+Allow user to edit Discount,允許用戶編輯折扣
+Get customers from,從中獲取客戶
+Include Exploded Items,包含爆炸物品
+"Buying must be checked, if Applicable For is selected as {0}",採購必須進行檢查，如果適用於被選擇為{0}
+Discount must be less than 100,折扣必須小於100,
+Restrict to Countries,限製到國家
+Synch Taxes and Charges,同步稅和費用
+Write Off Amount (Company Currency),核銷金額（公司貨幣）
+Billing Hours,結算時間
+Total Sales Amount (via Sales Order),總銷售額（通過銷售訂單）
+Default BOM for {0} not found,默認BOM {0}未找到
+Row #{0}: Please set reorder quantity,行＃{0}：請設置再訂購數量
+Tap items to add them here,點擊項目將其添加到此處
+Program Enrollment,招生計劃
+To Folio No,對開本No,
+Landed Cost Voucher,到岸成本憑證
+Please set {0},請設置{0}
+{0} - {1} is inactive student,{0}  -  {1}是非活動學生
+{0} - {1} is inactive student,{0}  -  {1}是非活動學生
+Health Details,健康細節
+Encashable days,可以忍受的日子
+To create a Payment Request reference document is required,要創建付款請求參考文檔是必需的
+To create a Payment Request reference document is required,要創建付款請求參考文檔是必需的
+Assessment  Manager,評估經理
+Allocate Payment Amount,分配付款金額
+Subscription Plan,訂閱計劃
+Salary,薪水
+Delivery Document Type,交付文件類型
+Do not update variants on save,不要在保存時更新變體
+Receivables,應收帳款
+Lead Source,主導來源
+Additional information regarding the customer.,對於客戶的其他訊息。
+Reading 5,閱讀5,
+"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} 與 {2} 關聯, 但當事方科目為 {3}"
+Bank Header,銀行標題
+View Lab Tests,查看實驗室測試
+Hub Users,Hub用戶
+Y,ÿ
+Maintenance Date,維修日期
+Rejected Serial No,拒絕序列號
+Year start date or end date is overlapping with {0}. To avoid please set company,新年的開始日期或結束日期與{0}重疊。為了避免請將公司
+Please mention the Lead Name in Lead {0},請提及潛在客戶名稱{0}
+Start date should be less than end date for Item {0},項目{0}的開始日期必須小於結束日期
+"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.","例如：ABCD ##### 
 如果串聯設定並且序列號沒有在交易中提到，然後自動序列號將在此基礎上創建的系列。如果你總是想明確提到序號為這個項目。留空。"
-DocType: Upload Attendance,Upload Attendance,上傳考勤
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +648,BOM and Manufacturing Quantity are required,BOM和生產量是必需的
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +35,Ageing Range 2,老齡範圍2
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29,Installing presets,安裝預置
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +113,No Delivery Note selected for Customer {},沒有為客戶{}選擇送貨單
-apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +17,Employee {0} has no maximum benefit amount,員工{0}沒有最大福利金額
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1211,Select Items based on Delivery Date,根據交付日期選擇項目
-DocType: Grant Application,Has any past Grant Record,有過去的贈款記錄嗎？
-,Sales Analytics,銷售分析
-,Prospects Engaged But Not Converted,展望未成熟
-,Prospects Engaged But Not Converted,展望未成熟
-DocType: Manufacturing Settings,Manufacturing Settings,製造設定
-apps/erpnext/erpnext/config/setup.py +56,Setting up Email,設定電子郵件
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Guardian1手機號碼
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +135,Please enter default currency in Company Master,請在公司主檔輸入預設貨幣
-DocType: Stock Entry Detail,Stock Entry Detail,存貨分錄明細
-apps/erpnext/erpnext/templates/pages/help.html +56,See all open tickets,查看所有打開的門票
-apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js +21,Healthcare Service Unit Tree,醫療服務單位樹
-apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +273,Product,產品
-DocType: Products Settings,Home Page is Products,首頁是產品頁
-,Asset Depreciation Ledger,資產減值總帳
-DocType: Salary Structure,Leave Encashment Amount Per Day,每天離開沖泡量
-DocType: Loyalty Program Collection,For how much spent = 1 Loyalty Point,花費多少= 1忠誠點
-apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +97,Tax Rule Conflicts with {0},稅收規範衝突{0}
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,New Account Name,新帳號名稱
-DocType: Purchase Invoice Item,Raw Materials Supplied Cost,原料供應成本
-DocType: Selling Settings,Settings for Selling Module,設置銷售模塊
-DocType: Hotel Room Reservation,Hotel Room Reservation,酒店房間預訂
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +388,Customer Service,顧客服務
-DocType: BOM,Thumbnail,縮略圖
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +383,No contacts with email IDs found.,找不到與電子郵件ID的聯繫人。
-DocType: Item Customer Detail,Item Customer Detail,項目客戶詳細
-DocType: Notification Control,Prompt for Email on Submission of,提示電子郵件的提交
-apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +36,Maximum benefit amount of employee {0} exceeds {1},員工{0}的最高福利金額超過{1}
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +102,Total allocated leaves are more than days in the period,分配的總葉多天的期限
-DocType: Linked Soil Analysis,Linked Soil Analysis,連接的土壤分析
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70,Item {0} must be a stock Item,項{0}必須是一個缺貨登記
-DocType: Manufacturing Settings,Default Work In Progress Warehouse,預設在製品倉庫
-apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +83,"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?",{0}重疊的時間表，是否要在滑動重疊的插槽後繼續？
-apps/erpnext/erpnext/config/accounts.py +256,Default settings for accounting transactions.,會計交易的預設設定。
-apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js +8,Grant Leaves,格蘭特葉子
-DocType: Restaurant,Default Tax Template,默認稅收模板
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +71,{0} Students have been enrolled,{0}學生已被註冊
-DocType: Fees,Student Details,學生細節
-DocType: Purchase Invoice Item,Stock Qty,庫存數量
-DocType: Purchase Invoice Item,Stock Qty,庫存數量
-DocType: QuickBooks Migrator,Default Shipping Account,默認運輸科目
-DocType: Loan,Repayment Period in Months,在月還款期
-apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26,Error: Not a valid id?,錯誤：沒有有效的身份證？
-DocType: Naming Series,Update Series Number,更新序列號
-DocType: Account,Equity,公平
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +79,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}：“損益”科目類型{2}不允許進入開
-DocType: Job Offer,Printing Details,印刷詳情
-DocType: Task,Closing Date,截止日期
-DocType: Sales Order Item,Produced Quantity,生產的產品數量
-DocType: Item Price,Quantity  that must be bought or sold per UOM,每個UOM必須購買或出售的數量
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +89,Engineer,工程師
-DocType: Employee Tax Exemption Category,Max Amount,最大金額
-DocType: Journal Entry,Total Amount Currency,總金額幣種
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,搜索子組件
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +200,Item Code required at Row No {0},於列{0}需要產品編號
-DocType: GST Account,SGST Account,SGST科目
-apps/erpnext/erpnext/utilities/user_progress.py +154,Go to Items,轉到項目
-DocType: Sales Partner,Partner Type,合作夥伴類型
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +72,Actual,實際
-DocType: Restaurant Menu,Restaurant Manager,餐廳經理
-DocType: Authorization Rule,Customerwise Discount,Customerwise折扣
-apps/erpnext/erpnext/config/projects.py +46,Timesheet for tasks.,時間表的任務。
-DocType: Purchase Invoice,Against Expense Account,對費用科目
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +287,Installation Note {0} has already been submitted,安裝注意{0}已提交
-DocType: Bank Reconciliation,Get Payment Entries,獲取付款項
-DocType: Quotation Item,Against Docname,對Docname
-DocType: SMS Center,All Employee (Active),所有員工（活動）
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9,View Now,立即觀看
-DocType: Woocommerce Settings,Woocommerce Server URL,Woocommerce服務器URL
-DocType: Item Reorder,Re-Order Level,重新排序級別
-DocType: Shopify Tax Account,Shopify Tax/Shipping Title,Shopify稅/運輸標題
-apps/erpnext/erpnext/projects/doctype/project/project.js +54,Gantt Chart,甘特圖
-DocType: Crop Cycle,Cycle Type,循環類型
-DocType: Employee,Applicable Holiday List,適用假期表
-DocType: Training Event,Employee Emails,員工電子郵件
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +67,Series Updated,系列更新
-apps/erpnext/erpnext/accounts/doctype/account/account.py +166,Report Type is mandatory,報告類型是強制性的
-DocType: Item,Serial Number Series,序列號系列
-apps/erpnext/erpnext/buying/utils.py +68,Warehouse is mandatory for stock Item {0} in row {1},倉庫是強制性的庫存項目{0}行{1}
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45,Retail & Wholesale,零售及批發
-DocType: Issue,First Responded On,首先作出回應
-DocType: Website Item Group,Cross Listing of Item in multiple groups,在多組項目的交叉上市
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},會計年度開始日期和財政年度結束日期已經在財政年度設置{0}
-DocType: Projects Settings,Ignore User Time Overlap,忽略用戶時間重疊
-DocType: Accounting Period,Accounting Period,會計期間
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +113,Clearance Date updated,間隙更新日期
-DocType: Stock Settings,Batch Identification,批次標識
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132,Successfully Reconciled,不甘心成功
-DocType: Request for Quotation Supplier,Download PDF,下載PDF
-DocType: Work Order,Planned End Date,計劃的結束日期
-DocType: Shareholder,Hidden list maintaining the list of contacts linked to Shareholder,隱藏列表維護鏈接到股東的聯繫人列表
-DocType: Exchange Rate Revaluation Account,Current Exchange Rate,當前匯率
-DocType: Item,"Sales, Purchase, Accounting Defaults",銷售，採購，會計違約
-apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,捐助者類型信息。
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +192,{0} on Leave on {1},{0}離開{1}
-DocType: Request for Quotation,Supplier Detail,供應商詳細
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +181,Error in formula or condition: {0},誤差在式或條件：{0}
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +119,Invoiced Amount,發票金額
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47,Criteria weights must add up to 100%,標準重量必須達100％
-apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,出勤
-apps/erpnext/erpnext/public/js/pos/pos.html +115,Stock Items,庫存產品
-DocType: Sales Invoice,Update Billed Amount in Sales Order,更新銷售訂單中的結算金額
-DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.",如果未選取，則該列表將被加到每個應被應用到的部門。
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +689,Posting date and posting time is mandatory,登錄日期和登錄時間是必需的
-apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,稅務模板購買交易。
-,Item Prices,產品價格
-DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,採購訂單一被儲存，就會顯示出來。
-DocType: Holiday List,Add to Holidays,加入假期
-DocType: Woocommerce Settings,Endpoint,端點
-DocType: Period Closing Voucher,Period Closing Voucher,期末券
-DocType: Patient Encounter,Review Details,評論細節
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +186,The shareholder does not belong to this company,股東不屬於這家公司
-DocType: Dosage Form,Dosage Form,劑型
-apps/erpnext/erpnext/config/selling.py +67,Price List master.,價格表主檔
-DocType: Task,Review Date,評論日期
-DocType: BOM,Allow Alternative Item,允許替代項目
-DocType: Company,Series for Asset Depreciation Entry (Journal Entry),資產折舊條目系列（期刊條目）
-DocType: Membership,Member Since,成員自
-DocType: Purchase Invoice,Advance Payments,預付款
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1754,Please select Healthcare Service,請選擇醫療保健服務
-DocType: Purchase Taxes and Charges,On Net Total,在總淨
-apps/erpnext/erpnext/controllers/item_variant.py +92,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},為屬性{0}值必須的範圍內{1}到{2}中的增量{3}為項目{4}
-DocType: Restaurant Reservation,Waitlisted,輪候
-DocType: Employee Tax Exemption Declaration Category,Exemption Category,豁免類別
-apps/erpnext/erpnext/accounts/doctype/account/account.py +131,Currency can not be changed after making entries using some other currency,貨幣不能使用其他貨幣進行輸入後更改
-DocType: Vehicle Service,Clutch Plate,離合器壓盤
-DocType: Company,Round Off Account,四捨五入科目
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +100,Administrative Expenses,行政開支
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18,Consulting,諮詢
-DocType: Subscription Plan,Based on price list,基於價格表
-DocType: Customer Group,Parent Customer Group,母客戶群組
-DocType: Vehicle Service,Change,更改
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +898,Subscription,訂閱
-DocType: Purchase Invoice,Contact Email,聯絡電郵
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,費用創作待定
-DocType: Appraisal Goal,Score Earned,得分
-DocType: Asset Category,Asset Category Name,資產類別名稱
-apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,This is a root territory and cannot be edited.,集團或Ledger ，借方或貸方，是特等科目
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5,New Sales Person Name,新銷售人員的姓名
-DocType: Packing Slip,Gross Weight UOM,毛重計量單位
-DocType: Employee Transfer,Create New Employee Id,創建新的員工ID
-apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js +26,Set Details,設置細節
-DocType: Travel Itinerary,Travel From,旅行從
-DocType: Asset Maintenance Task,Preventive Maintenance,預防性的維護
-DocType: Delivery Note Item,Against Sales Invoice,對銷售發票
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +158,Please enter serial numbers for serialized item ,請輸入序列號序列號
-DocType: Bin,Reserved Qty for Production,預留數量生產
-DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,如果您不想在製作基於課程的組時考慮批量，請不要選中。
-DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,如果您不想在製作基於課程的組時考慮批量，請不要選中。
-DocType: Asset,Frequency of Depreciation (Months),折舊率（月）
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +542,Credit Account,信用科目
-DocType: Landed Cost Item,Landed Cost Item,到岸成本項目
-apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +58,Show zero values,顯示零值
-DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,製造/從原材料數量給予重新包裝後獲得的項目數量
-DocType: Lab Test,Test Group,測試組
-DocType: Payment Reconciliation,Receivable / Payable Account,應收/應付帳款
-DocType: Delivery Note Item,Against Sales Order Item,對銷售訂單項目
-DocType: Company,Company Logo,公司標誌
-apps/erpnext/erpnext/stock/doctype/item/item.py +787,Please specify Attribute Value for attribute {0},請指定屬性值的屬性{0}
-DocType: QuickBooks Migrator,Default Warehouse,預設倉庫
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +55,Budget cannot be assigned against Group Account {0},不能指定預算給群組帳目{0}
-DocType: Shopping Cart Settings,Show Price,顯示價格
-DocType: Healthcare Settings,Patient Registration,病人登記
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,Please enter parent cost center,請輸入父成本中心
-DocType: Delivery Note,Print Without Amount,列印表單時不印金額
-apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +92,Depreciation Date,折舊日期
-,Work Orders in Progress,工作訂單正在進行中
-DocType: Issue,Support Team,支持團隊
-apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36,Expiry (In Days),到期（天數）
-DocType: Appraisal,Total Score (Out of 5),總分（滿分5分）
-DocType: Student Attendance Tool,Batch,批量
-DocType: Support Search Source,Query Route String,查詢路由字符串
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1172,Update rate as per last purchase,根據上次購買更新率
-DocType: Donor,Donor Type,捐助者類型
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +710,Auto repeat document updated,自動重複文件更新
-apps/erpnext/erpnext/stock/doctype/item/item.js +29,Balance,餘額
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66,Please select the Company,請選擇公司
-DocType: Room,Seating Capacity,座位數
-DocType: Lab Test Groups,Lab Test Groups,實驗室測試組
-apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py +151,Party Type and Party is mandatory for {0} account,{0}科目的參與方以及類型為必填
-DocType: Project,Total Expense Claim (via Expense Claims),總費用報銷（通過費用報銷）
-DocType: GST Settings,GST Summary,消費稅總結
-apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py +16,Please enable default incoming account before creating Daily Work Summary Group,請在創建日常工作摘要組之前啟用默認傳入科目
-DocType: Assessment Result,Total Score,總得分
-DocType: Crop Cycle,ISO 8601 standard,ISO 8601標準
-DocType: Journal Entry,Debit Note,繳費單
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1517,You can only redeem max {0} points in this order.,您只能按此順序兌換最多{0}個積分。
-apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py +102,Please enter API Consumer Secret,請輸入API消費者密碼
-DocType: Stock Entry,As per Stock UOM,按庫存計量單位
-apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,沒有過期
-DocType: Student Log,Achievement,成就
-DocType: Asset,Insurer,保險公司
-DocType: Batch,Source Document Type,源文檔類型
-DocType: Batch,Source Document Type,源文檔類型
-apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24,Following course schedules were created,按照課程時間表創建
-DocType: Employee Onboarding,Employee Onboarding,員工入職
-DocType: Journal Entry,Total Debit,借方總額
-DocType: Travel Request Costing,Sponsored Amount,贊助金額
-DocType: Manufacturing Settings,Default Finished Goods Warehouse,預設成品倉庫
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +380,Please select Patient,請選擇患者
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Sales Person,銷售人員
-DocType: Hotel Room Package,Amenities,設施
-DocType: QuickBooks Migrator,Undeposited Funds Account,未存入資金科目
-apps/erpnext/erpnext/config/accounts.py +201,Budget and Cost Center,預算和成本中心
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65,Multiple default mode of payment is not allowed,不允許多種默認付款方式
-DocType: Sales Invoice,Loyalty Points Redemption,忠誠積分兌換
-,Appointment Analytics,預約分析
-DocType: Lead,Blog Subscriber,網誌訂閱者
-DocType: Guardian,Alternate Number,備用號碼
-apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,創建規則來限制基於價值的交易。
-DocType: Cash Flow Mapping Accounts,Cash Flow Mapping Accounts,現金流量映射科目
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,組卷號
-DocType: Batch,Manufacturing Date,生產日期
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,費用創作失敗
-DocType: Opening Invoice Creation Tool,Create Missing Party,創建失踪派對
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +85,Total Budget,預算總額
-DocType: Student Group Creation Tool,Leave blank if you make students groups per year,如果您每年製作學生團體，請留空
-DocType: Student Group Creation Tool,Leave blank if you make students groups per year,如果您每年製作學生團體，請留空
-DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day",如果選中，則總數。工作日將包括節假日，這將縮短每天的工資的價值
-apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js +25,"Apps using current key won't be able to access, are you sure?",使用當前密鑰的應用程序將無法訪問，您確定嗎？
-DocType: Purchase Invoice,Total Advance,預付款總計
-apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js +78,Change Template Code,更改模板代碼
-apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +23,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,該期限結束日期不能超過期限開始日期。請更正日期，然後再試一次。
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,報價
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,報價計數
-DocType: Bank Statement Transaction Entry,Bank Statement,銀行對帳單
-DocType: Employee Benefit Claim,Max Amount Eligible,最高金額合格
-,BOM Stock Report,BOM庫存報告
-DocType: Stock Reconciliation Item,Quantity Difference,數量差異
-DocType: Opportunity Item,Basic Rate,基礎匯率
-DocType: GL Entry,Credit Amount,信貸金額
-DocType: Cheque Print Template,Signatory Position,簽署的位置
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +184,Set as Lost,設為失落
-DocType: Timesheet,Total Billable Hours,總計費時間
-DocType: Subscription,Number of days that the subscriber has to pay invoices generated by this subscription,用戶必須支付此訂閱生成的發票的天數
-DocType: Employee Benefit Application Detail,Employee Benefit Application Detail,員工福利申請明細
-apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,付款收貨注意事項
-apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,這是基於對這個顧客的交易。詳情請參閱以下時間表
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +162,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},行{0}：分配金額{1}必須小於或等於輸入付款金額{2}
-DocType: Program Enrollment Tool,New Academic Term,新學期
-,Course wise Assessment Report,課程明智的評估報告
-DocType: Purchase Invoice,Availed ITC State/UT Tax,有效的ITC州/ UT稅
-DocType: Tax Rule,Tax Rule,稅務規則
-DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,保持同樣的速度在整個銷售週期
-apps/erpnext/erpnext/hub_node/api.py +49,Please login as another user to register on Marketplace,請以另一個用戶身份登錄以在Marketplace上註冊
-DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,在工作站的工作時間以外計畫時間日誌。
-apps/erpnext/erpnext/public/js/pos/pos.html +98,Customers in Queue,在排隊的客戶
-DocType: Driver,Issuing Date,發行日期
-DocType: Procedure Prescription,Appointment Booked,預約預約
-DocType: Student,Nationality,國籍
-apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +108,Submit this Work Order for further processing.,提交此工單以進一步處理。
-,Items To Be Requested,需求項目
-DocType: Company,Company Info,公司資訊
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1399,Select or add new customer,選擇或添加新客戶
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +177,Cost center is required to book an expense claim,成本中心需要預訂費用報銷
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),基金中的應用（資產）
-apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,這是基於該員工的考勤
-DocType: Payment Request,Payment Request Type,付款申請類型
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +113,Mark Attendance,出席人數
-DocType: Fiscal Year,Year Start Date,年結開始日期
-DocType: Additional Salary,Employee Name,員工姓名
-DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,餐廳訂單錄入項目
-DocType: Purchase Invoice,Rounded Total (Company Currency),整數總計（公司貨幣）
-apps/erpnext/erpnext/accounts/doctype/account/account.py +103,Cannot covert to Group because Account Type is selected.,不能轉換到群組科目，因為科目類型選擇的。
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +276,{0} {1} has been modified. Please refresh.,{0} {1} 已修改。請更新。
-DocType: Leave Block List,Stop users from making Leave Applications on following days.,停止用戶在下面日期提出休假申請。
-apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +24,"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.",如果忠誠度積分無限期到期，請將到期時間保持為空或0。
-DocType: Asset Maintenance Team,Maintenance Team Members,維護團隊成員
-DocType: Loyalty Point Entry,Purchase Amount,購買金額
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +251,"Cannot deliver Serial No {0} of item {1} as it is reserved \
+Upload Attendance,上傳考勤
+BOM and Manufacturing Quantity are required,BOM和生產量是必需的
+Ageing Range 2,老齡範圍2,
+Installing presets,安裝預置
+No Delivery Note selected for Customer {},沒有為客戶{}選擇送貨單
+Employee {0} has no maximum benefit amount,員工{0}沒有最大福利金額
+Select Items based on Delivery Date,根據交付日期選擇項目
+Has any past Grant Record,有過去的贈款記錄嗎？
+Sales Analytics,銷售分析
+Prospects Engaged But Not Converted,展望未成熟
+Prospects Engaged But Not Converted,展望未成熟
+Manufacturing Settings,製造設定
+Setting up Email,設定電子郵件
+Guardian1 Mobile No,Guardian1手機號碼
+Please enter default currency in Company Master,請在公司主檔輸入預設貨幣
+Stock Entry Detail,存貨分錄明細
+See all open tickets,查看所有打開的門票
+Healthcare Service Unit Tree,醫療服務單位樹
+Product,產品
+Home Page is Products,首頁是產品頁
+Asset Depreciation Ledger,資產減值總帳
+Leave Encashment Amount Per Day,每天離開沖泡量
+For how much spent = 1 Loyalty Point,花費多少= 1忠誠點
+Tax Rule Conflicts with {0},稅收規範衝突{0}
+New Account Name,新帳號名稱
+Raw Materials Supplied Cost,原料供應成本
+Settings for Selling Module,設置銷售模塊
+Hotel Room Reservation,酒店房間預訂
+Customer Service,顧客服務
+Thumbnail,縮略圖
+No contacts with email IDs found.,找不到與電子郵件ID的聯繫人。
+Item Customer Detail,項目客戶詳細
+Prompt for Email on Submission of,提示電子郵件的提交
+Maximum benefit amount of employee {0} exceeds {1},員工{0}的最高福利金額超過{1}
+Total allocated leaves are more than days in the period,分配的總葉多天的期限
+Linked Soil Analysis,連接的土壤分析
+Item {0} must be a stock Item,項{0}必須是一個缺貨登記
+Default Work In Progress Warehouse,預設在製品倉庫
+"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?",{0}重疊的時間表，是否要在滑動重疊的插槽後繼續？
+Default settings for accounting transactions.,會計交易的預設設定。
+Grant Leaves,格蘭特葉子
+Default Tax Template,默認稅收模板
+{0} Students have been enrolled,{0}學生已被註冊
+Student Details,學生細節
+Stock Qty,庫存數量
+Stock Qty,庫存數量
+Default Shipping Account,默認運輸科目
+Repayment Period in Months,在月還款期
+Error: Not a valid id?,錯誤：沒有有效的身份證？
+Update Series Number,更新序列號
+Equity,公平
+{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}：“損益”科目類型{2}不允許進入開
+Printing Details,印刷詳情
+Closing Date,截止日期
+Produced Quantity,生產的產品數量
+Quantity  that must be bought or sold per UOM,每個UOM必須購買或出售的數量
+Engineer,工程師
+Max Amount,最大金額
+Total Amount Currency,總金額幣種
+Search Sub Assemblies,搜索子組件
+Item Code required at Row No {0},於列{0}需要產品編號
+SGST Account,SGST科目
+Go to Items,轉到項目
+Partner Type,合作夥伴類型
+Actual,實際
+Restaurant Manager,餐廳經理
+Customerwise Discount,Customerwise折扣
+Timesheet for tasks.,時間表的任務。
+Against Expense Account,對費用科目
+Installation Note {0} has already been submitted,安裝注意{0}已提交
+Get Payment Entries,獲取付款項
+Against Docname,對Docname,
+All Employee (Active),所有員工（活動）
+View Now,立即觀看
+Woocommerce Server URL,Woocommerce服務器URL,
+Re-Order Level,重新排序級別
+Shopify Tax/Shipping Title,Shopify稅/運輸標題
+Gantt Chart,甘特圖
+Cycle Type,循環類型
+Applicable Holiday List,適用假期表
+Employee Emails,員工電子郵件
+Series Updated,系列更新
+Report Type is mandatory,報告類型是強制性的
+Serial Number Series,序列號系列
+Warehouse is mandatory for stock Item {0} in row {1},倉庫是強制性的庫存項目{0}行{1}
+Retail & Wholesale,零售及批發
+First Responded On,首先作出回應
+Cross Listing of Item in multiple groups,在多組項目的交叉上市
+Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},會計年度開始日期和財政年度結束日期已經在財政年度設置{0}
+Ignore User Time Overlap,忽略用戶時間重疊
+Accounting Period,會計期間
+Clearance Date updated,間隙更新日期
+Batch Identification,批次標識
+Successfully Reconciled,不甘心成功
+Download PDF,下載PDF,
+Planned End Date,計劃的結束日期
+Hidden list maintaining the list of contacts linked to Shareholder,隱藏列表維護鏈接到股東的聯繫人列表
+Current Exchange Rate,當前匯率
+"Sales, Purchase, Accounting Defaults",銷售，採購，會計違約
+Donor Type information.,捐助者類型信息。
+{0} on Leave on {1},{0}離開{1}
+Supplier Detail,供應商詳細
+Error in formula or condition: {0},誤差在式或條件：{0}
+Invoiced Amount,發票金額
+Criteria weights must add up to 100%,標準重量必須達100％
+Attendance,出勤
+Stock Items,庫存產品
+Update Billed Amount in Sales Order,更新銷售訂單中的結算金額
+"If not checked, the list will have to be added to each Department where it has to be applied.",如果未選取，則該列表將被加到每個應被應用到的部門。
+Posting date and posting time is mandatory,登錄日期和登錄時間是必需的
+Tax template for buying transactions.,稅務模板購買交易。
+Item Prices,產品價格
+In Words will be visible once you save the Purchase Order.,採購訂單一被儲存，就會顯示出來。
+Add to Holidays,加入假期
+Endpoint,端點
+Period Closing Voucher,期末券
+Review Details,評論細節
+The shareholder does not belong to this company,股東不屬於這家公司
+Dosage Form,劑型
+Price List master.,價格表主檔
+Review Date,評論日期
+Allow Alternative Item,允許替代項目
+Series for Asset Depreciation Entry (Journal Entry),資產折舊條目系列（期刊條目）
+Member Since,成員自
+Advance Payments,預付款
+Please select Healthcare Service,請選擇醫療保健服務
+On Net Total,在總淨
+Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},為屬性{0}值必須的範圍內{1}到{2}中的增量{3}為項目{4}
+Waitlisted,輪候
+Exemption Category,豁免類別
+Currency can not be changed after making entries using some other currency,貨幣不能使用其他貨幣進行輸入後更改
+Clutch Plate,離合器壓盤
+Round Off Account,四捨五入科目
+Administrative Expenses,行政開支
+Consulting,諮詢
+Based on price list,基於價格表
+Parent Customer Group,母客戶群組
+Change,更改
+Subscription,訂閱
+Contact Email,聯絡電郵
+Fee Creation Pending,費用創作待定
+Score Earned,得分
+Asset Category Name,資產類別名稱
+This is a root territory and cannot be edited.,集團或Ledger ，借方或貸方，是特等科目
+New Sales Person Name,新銷售人員的姓名
+Gross Weight UOM,毛重計量單位
+Create New Employee Id,創建新的員工ID,
+Set Details,設置細節
+Travel From,旅行從
+Preventive Maintenance,預防性的維護
+Against Sales Invoice,對銷售發票
+Please enter serial numbers for serialized item ,請輸入序列號序列號
+Reserved Qty for Production,預留數量生產
+Leave unchecked if you don't want to consider batch while making course based groups. ,如果您不想在製作基於課程的組時考慮批量，請不要選中。
+Leave unchecked if you don't want to consider batch while making course based groups. ,如果您不想在製作基於課程的組時考慮批量，請不要選中。
+Frequency of Depreciation (Months),折舊率（月）
+Credit Account,信用科目
+Landed Cost Item,到岸成本項目
+Show zero values,顯示零值
+Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,製造/從原材料數量給予重新包裝後獲得的項目數量
+Test Group,測試組
+Receivable / Payable Account,應收/應付帳款
+Against Sales Order Item,對銷售訂單項目
+Company Logo,公司標誌
+Please specify Attribute Value for attribute {0},請指定屬性值的屬性{0}
+Default Warehouse,預設倉庫
+Budget cannot be assigned against Group Account {0},不能指定預算給群組帳目{0}
+Show Price,顯示價格
+Patient Registration,病人登記
+Please enter parent cost center,請輸入父成本中心
+Print Without Amount,列印表單時不印金額
+Depreciation Date,折舊日期
+Work Orders in Progress,工作訂單正在進行中
+Support Team,支持團隊
+Expiry (In Days),到期（天數）
+Total Score (Out of 5),總分（滿分5分）
+Batch,批量
+Query Route String,查詢路由字符串
+Update rate as per last purchase,根據上次購買更新率
+Donor Type,捐助者類型
+Auto repeat document updated,自動重複文件更新
+Balance,餘額
+Please select the Company,請選擇公司
+Seating Capacity,座位數
+Lab Test Groups,實驗室測試組
+Party Type and Party is mandatory for {0} account,{0}科目的參與方以及類型為必填
+Total Expense Claim (via Expense Claims),總費用報銷（通過費用報銷）
+GST Summary,消費稅總結
+Please enable default incoming account before creating Daily Work Summary Group,請在創建日常工作摘要組之前啟用默認傳入科目
+Total Score,總得分
+ISO 8601 standard,ISO 8601標準
+Debit Note,繳費單
+You can only redeem max {0} points in this order.,您只能按此順序兌換最多{0}個積分。
+Please enter API Consumer Secret,請輸入API消費者密碼
+As per Stock UOM,按庫存計量單位
+Not Expired,沒有過期
+Achievement,成就
+Insurer,保險公司
+Source Document Type,源文檔類型
+Source Document Type,源文檔類型
+Following course schedules were created,按照課程時間表創建
+Employee Onboarding,員工入職
+Total Debit,借方總額
+Sponsored Amount,贊助金額
+Default Finished Goods Warehouse,預設成品倉庫
+Please select Patient,請選擇患者
+Sales Person,銷售人員
+Amenities,設施
+Undeposited Funds Account,未存入資金科目
+Budget and Cost Center,預算和成本中心
+Multiple default mode of payment is not allowed,不允許多種默認付款方式
+Loyalty Points Redemption,忠誠積分兌換
+Appointment Analytics,預約分析
+Blog Subscriber,網誌訂閱者
+Alternate Number,備用號碼
+Create rules to restrict transactions based on values.,創建規則來限制基於價值的交易。
+Cash Flow Mapping Accounts,現金流量映射科目
+ Group Roll No,組卷號
+Manufacturing Date,生產日期
+Fee Creation Failed,費用創作失敗
+Create Missing Party,創建失踪派對
+Total Budget,預算總額
+Leave blank if you make students groups per year,如果您每年製作學生團體，請留空
+Leave blank if you make students groups per year,如果您每年製作學生團體，請留空
+"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day",如果選中，則總數。工作日將包括節假日，這將縮短每天的工資的價值
+"Apps using current key won't be able to access, are you sure?",使用當前密鑰的應用程序將無法訪問，您確定嗎？
+Total Advance,預付款總計
+Change Template Code,更改模板代碼
+The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,該期限結束日期不能超過期限開始日期。請更正日期，然後再試一次。
+Quot Count,報價
+Quot Count,報價計數
+Bank Statement,銀行對帳單
+Max Amount Eligible,最高金額合格
+BOM Stock Report,BOM庫存報告
+Quantity Difference,數量差異
+Basic Rate,基礎匯率
+Credit Amount,信貸金額
+Signatory Position,簽署的位置
+Set as Lost,設為失落
+Total Billable Hours,總計費時間
+Number of days that the subscriber has to pay invoices generated by this subscription,用戶必須支付此訂閱生成的發票的天數
+Employee Benefit Application Detail,員工福利申請明細
+Payment Receipt Note,付款收貨注意事項
+This is based on transactions against this Customer. See timeline below for details,這是基於對這個顧客的交易。詳情請參閱以下時間表
+Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},行{0}：分配金額{1}必須小於或等於輸入付款金額{2}
+New Academic Term,新學期
+Course wise Assessment Report,課程明智的評估報告
+Availed ITC State/UT Tax,有效的ITC州/ UT稅
+Tax Rule,稅務規則
+Maintain Same Rate Throughout Sales Cycle,保持同樣的速度在整個銷售週期
+Please login as another user to register on Marketplace,請以另一個用戶身份登錄以在Marketplace上註冊
+Plan time logs outside Workstation Working Hours.,在工作站的工作時間以外計畫時間日誌。
+Customers in Queue,在排隊的客戶
+Issuing Date,發行日期
+Appointment Booked,預約預約
+Nationality,國籍
+Submit this Work Order for further processing.,提交此工單以進一步處理。
+Items To Be Requested,需求項目
+Company Info,公司資訊
+Select or add new customer,選擇或添加新客戶
+Cost center is required to book an expense claim,成本中心需要預訂費用報銷
+Application of Funds (Assets),基金中的應用（資產）
+This is based on the attendance of this Employee,這是基於該員工的考勤
+Payment Request Type,付款申請類型
+Mark Attendance,出席人數
+Year Start Date,年結開始日期
+Employee Name,員工姓名
+Restaurant Order Entry Item,餐廳訂單錄入項目
+Rounded Total (Company Currency),整數總計（公司貨幣）
+Cannot covert to Group because Account Type is selected.,不能轉換到群組科目，因為科目類型選擇的。
+{0} {1} has been modified. Please refresh.,{0} {1} 已修改。請更新。
+Stop users from making Leave Applications on following days.,停止用戶在下面日期提出休假申請。
+"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.",如果忠誠度積分無限期到期，請將到期時間保持為空或0。
+Maintenance Team Members,維護團隊成員
+Purchase Amount,購買金額
+"Cannot deliver Serial No {0} of item {1} as it is reserved \
 											to fullfill Sales Order {2}",無法交付項目{1}的序列號{0}，因為它已保留\以滿足銷售訂單{2}
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +261,Supplier Quotation {0} created,供應商報價{0}創建
-apps/erpnext/erpnext/accounts/report/financial_statements.py +106,End Year cannot be before Start Year,結束年份不能啟動年前
-DocType: Employee Benefit Application,Employee Benefits,員工福利
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +269,Packed quantity must equal quantity for Item {0} in row {1},盒裝數量必須等於{1}列品項{0}的數量
-DocType: Work Order,Manufactured Qty,生產數量
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +79,The shares don't exist with the {0},這些份額不存在於{0}
-DocType: Sales Partner Type,Sales Partner Type,銷售夥伴類型
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64,Invoice Created,已創建發票
-DocType: Asset,Out of Order,亂序
-DocType: Purchase Receipt Item,Accepted Quantity,允收數量
-DocType: Projects Settings,Ignore Workstation Time Overlap,忽略工作站時間重疊
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +302,Please set a default Holiday List for Employee {0} or Company {1},請設置一個默認的假日列表為員工{0}或公司{1}
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +78,Select Batch Numbers,選擇批號
-apps/erpnext/erpnext/config/accounts.py +14,Bills raised to Customers.,客戶提出的賬單。
-DocType: Healthcare Settings,Invoice Appointments Automatically,自動發票約會
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,項目編號
-DocType: Salary Component,Variable Based On Taxable Salary,基於應納稅工資的變量
-DocType: Company,Basic Component,基本組件
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +578,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},行無{0}：金額不能大於金額之前對報銷{1}。待審核金額為{2}
-DocType: Patient Service Unit,Medical Administrator,醫療管理員
-DocType: Assessment Plan,Schedule,時間表
-DocType: Account,Parent Account,上層科目
-DocType: Quality Inspection Reading,Reading 3,閱讀3
-DocType: Stock Entry,Source Warehouse Address,來源倉庫地址
-DocType: GL Entry,Voucher Type,憑證類型
-DocType: Amazon MWS Settings,Max Retry Limit,最大重試限制
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1731,Price List not found or disabled,價格表未找到或被禁用
-DocType: Student Applicant,Approved,批准
-apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15,Price,價格
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +349,Employee relieved on {0} must be set as 'Left',員工解除對{0}必須設定為“左”
-DocType: Marketplace Settings,Last Sync On,上次同步開啟
-DocType: Guardian,Guardian,監護人
-apps/erpnext/erpnext/support/doctype/issue/issue.js +48,All communications including and above this shall be moved into the new Issue,包括及以上的所有通信均應移至新發行中
-DocType: Salary Detail,Tax on additional salary,額外工資稅
-DocType: Item Alternative,Item Alternative,項目選擇
-DocType: Healthcare Settings,Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,如果未在醫生執業者中設置預約費用，則使用默認收入帳戶。
-DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,創建缺少的客戶或供應商。
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,鑑定{0}為員工在給定日期範圍{1}創建
-DocType: Payroll Entry,Salary Slips Created,工資單創建
-DocType: Inpatient Record,Expected Discharge,預期解僱
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +594,Del,刪除
-DocType: Selling Settings,Campaign Naming By,活動命名由
-DocType: Employee,Current Address Is,當前地址是
-apps/erpnext/erpnext/utilities/user_progress.py +51,Monthly Sales Target (,每月銷售目標（
-DocType: Travel Request,Identification Document Number,身份證明文件號碼
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +41,"Optional. Sets company's default currency, if not specified.",可選。設置公司的默認貨幣，如果沒有指定。
-DocType: Sales Invoice,Customer GSTIN,客戶GSTIN
-DocType: Crop Cycle,List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,在現場檢測到的疾病清單。當選擇它會自動添加一個任務清單處理疾病
-apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js +30,This is a root healthcare service unit and cannot be edited.,這是根醫療保健服務單位，不能編輯。
-DocType: Asset Repair,Repair Status,維修狀態
-apps/erpnext/erpnext/public/js/event.js +31,Add Sales Partners,添加銷售合作夥伴
-apps/erpnext/erpnext/config/accounts.py +45,Accounting journal entries.,會計日記帳分錄。
-DocType: Travel Request,Travel Request,旅行要求
-DocType: Delivery Note Item,Available Qty at From Warehouse,可用數量從倉庫
-apps/erpnext/erpnext/hr/doctype/department_approver/department_approver.py +17,Please select Employee Record first.,請選擇員工記錄第一。
-apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py +52,Attendance not submitted for {0} as it is a Holiday.,由於是假期，因此未出席{0}的考勤。
-DocType: POS Profile,Account for Change Amount,帳戶漲跌額
-DocType: QuickBooks Migrator,Connecting to QuickBooks,連接到QuickBooks
-DocType: Exchange Rate Revaluation,Total Gain/Loss,總收益/損失
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1175,Invalid Company for Inter Company Invoice.,公司發票無效公司。
-DocType: Purchase Invoice,input service,輸入服務
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +249,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},行{0}：甲方/客戶不與匹配{1} / {2} {3} {4}
-DocType: Employee Promotion,Employee Promotion,員工晉升
-DocType: Maintenance Team Member,Maintenance Team Member,維護團隊成員
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16,Course Code: ,課程編號：
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +241,Please enter Expense Account,請輸入您的費用科目
-DocType: Account,Stock,庫存
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1128,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry",行＃{0}：參考文件類型必須是採購訂單之一，購買發票或日記帳分錄
-DocType: Employee,Current Address,當前地址
-DocType: Item,"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified",如果項目是另一項目，然後描述，圖像，定價，稅費等會從模板中設定的一個變體，除非明確指定
-DocType: Serial No,Purchase / Manufacture Details,採購／製造詳細資訊
-DocType: Assessment Group,Assessment Group,評估小組
-apps/erpnext/erpnext/config/stock.py +332,Batch Inventory,批量庫存
-DocType: Supplier,GST Transporter ID,消費稅轉運ID
-DocType: Procedure Prescription,Procedure Name,程序名稱
-DocType: Employee,Contract End Date,合同結束日期
-DocType: Amazon MWS Settings,Seller ID,賣家ID
-DocType: Sales Order,Track this Sales Order against any Project,跟踪對任何項目這個銷售訂單
-DocType: Bank Statement Transaction Entry,Bank Statement Transaction Entry,銀行對賬單交易分錄
-DocType: Sales Invoice Item,Discount and Margin,折扣和保證金
-DocType: Lab Test,Prescription,處方
-DocType: Company,Default Deferred Revenue Account,默認遞延收入科目
-DocType: Project,Second Email,第二封郵件
-DocType: Budget,Action if Annual Budget Exceeded on Actual,年度預算超出實際的行動
-DocType: Pricing Rule,Min Qty,最小數量
-DocType: Production Plan Item,Planned Qty,計劃數量
-DocType: Company,Date of Incorporation,註冊成立日期
-apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,總稅收
-apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py +40,Last Purchase Price,上次購買價格
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +284,For Quantity (Manufactured Qty) is mandatory,對於數量（製造數量）是強制性的
-DocType: Stock Entry,Default Target Warehouse,預設目標倉庫
-DocType: Purchase Invoice,Net Total (Company Currency),總淨值（公司貨幣）
-DocType: Delivery Note,Air,空氣
-apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,年末日期不能超過年度開始日期。請更正日期，然後再試一次。
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +277,{0} is not in Optional Holiday List,{0}不在可選節日列表中
-DocType: Notification Control,Purchase Receipt Message,採購入庫單訊息
-DocType: BOM,Scrap Items,廢物品
-DocType: Job Card,Actual Start Date,實際開始日期
-DocType: Sales Order,% of materials delivered against this Sales Order,針對這張銷售訂單的已交貨物料的百分比(%)
-apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Work Orders.,生成材料請求（MRP）和工作訂單。
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62,Set default mode of payment,設置默認付款方式
-DocType: BOM,With Operations,加入作業
-DocType: Support Search Source,Post Route Key List,發布路由密鑰列表
-apps/erpnext/erpnext/accounts/party.py +288,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,會計分錄已取得貨幣{0}為公司{1}。請選擇一個應收或應付科目幣種{0}。
-DocType: Asset,Is Existing Asset,是對現有資產
-DocType: Salary Component,Statistical Component,統計組成部分
-DocType: Salary Component,Statistical Component,統計組成部分
-DocType: Warranty Claim,If different than customer address,如果與客戶地址不同
-DocType: Purchase Invoice,Without Payment of Tax,不繳納稅款
-DocType: BOM Operation,BOM Operation,BOM的操作
-DocType: Purchase Taxes and Charges,On Previous Row Amount,在上一行金額
-DocType: Item,Has Expiry Date,有過期日期
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +367,Transfer Asset,轉讓資產
-DocType: POS Profile,POS Profile,POS簡介
-DocType: Training Event,Event Name,事件名稱
-DocType: Healthcare Practitioner,Phone (Office),電話（辦公室）
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +21,"Cannot Submit, Employees left to mark attendance",無法提交，僱員留下來標記出席
-DocType: Inpatient Record,Admission,入場
-apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29,Admissions for {0},招生{0}
-apps/erpnext/erpnext/config/accounts.py +225,"Seasonality for setting budgets, targets etc.",季節性設置預算，目標等。
-DocType: Supplier Scorecard Scoring Variable,Variable Name,變量名
-apps/erpnext/erpnext/stock/get_item_details.py +163,"Item {0} is a template, please select one of its variants",項目{0}是一個模板，請選擇它的一個變體
-DocType: Purchase Invoice Item,Deferred Expense,遞延費用
-apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py +26,From Date {0} cannot be before employee's joining Date {1},起始日期{0}不能在員工加入日期之前{1}
-DocType: Asset,Asset Category,資產類別
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39,Net pay cannot be negative,淨工資不能為負
-DocType: Purchase Order,Advance Paid,提前支付
-DocType: Manufacturing Settings,Overproduction Percentage For Sales Order,銷售訂單超額生產百分比
-DocType: Item,Item Tax,產品稅
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +951,Material to Supplier,材料到供應商
-DocType: Production Plan,Material Request Planning,物料請求計劃
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +708,Excise Invoice,消費稅發票
-apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Treshold {0}出現％不止一次
-DocType: Expense Claim,Employees Email Id,員工的電子郵件ID
-DocType: Employee Attendance Tool,Marked Attendance,明顯考勤
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145,Current Liabilities,流動負債
-apps/erpnext/erpnext/public/js/projects/timer.js +138,Timer exceeded the given hours.,計時器超出了指定的小時數
-apps/erpnext/erpnext/config/selling.py +303,Send mass SMS to your contacts,發送群發短信到您的聯絡人
-DocType: Inpatient Record,A Positive,積極的
-DocType: Program,Program Name,程序名稱
-DocType: Purchase Taxes and Charges,Consider Tax or Charge for,考慮稅收或收費
-DocType: Driver,Driving License Category,駕駛執照類別
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,實際數量是強制性
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +89,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0}目前擁有{1}供應商記分卡，而採購訂單應謹慎提供給供應商。
-DocType: Asset Maintenance Team,Asset Maintenance Team,資產維護團隊
-DocType: Loan,Loan Type,貸款類型
-DocType: Scheduling Tool,Scheduling Tool,調度工具
-DocType: BOM,Item to be manufactured or repacked,產品被製造或重新包裝
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +766,Syntax error in condition: {0},條件中的語法錯誤：{0}
-DocType: Employee Education,Major/Optional Subjects,大/選修課
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +121,Please Set Supplier Group in Buying Settings.,請設置供應商組購買設置。
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,"Total flexible benefit component amount {0} should not be less \
+Supplier Quotation {0} created,供應商報價{0}創建
+End Year cannot be before Start Year,結束年份不能啟動年前
+Employee Benefits,員工福利
+Packed quantity must equal quantity for Item {0} in row {1},盒裝數量必須等於{1}列品項{0}的數量
+Manufactured Qty,生產數量
+The shares don't exist with the {0},這些份額不存在於{0}
+Sales Partner Type,銷售夥伴類型
+Invoice Created,已創建發票
+Out of Order,亂序
+Accepted Quantity,允收數量
+Ignore Workstation Time Overlap,忽略工作站時間重疊
+Please set a default Holiday List for Employee {0} or Company {1},請設置一個默認的假日列表為員工{0}或公司{1}
+Select Batch Numbers,選擇批號
+Bills raised to Customers.,客戶提出的賬單。
+Invoice Appointments Automatically,自動發票約會
+Project Id,項目編號
+Variable Based On Taxable Salary,基於應納稅工資的變量
+Basic Component,基本組件
+Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},行無{0}：金額不能大於金額之前對報銷{1}。待審核金額為{2}
+Medical Administrator,醫療管理員
+Schedule,時間表
+Parent Account,上層科目
+Reading 3,閱讀3,
+Source Warehouse Address,來源倉庫地址
+Voucher Type,憑證類型
+Max Retry Limit,最大重試限制
+Price List not found or disabled,價格表未找到或被禁用
+Approved,批准
+Price,價格
+Employee relieved on {0} must be set as 'Left',員工解除對{0}必須設定為“左”
+Last Sync On,上次同步開啟
+Guardian,監護人
+All communications including and above this shall be moved into the new Issue,包括及以上的所有通信均應移至新發行中
+Tax on additional salary,額外工資稅
+Item Alternative,項目選擇
+Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,如果未在醫生執業者中設置預約費用，則使用默認收入帳戶。
+Create missing customer or supplier.,創建缺少的客戶或供應商。
+Appraisal {0} created for Employee {1} in the given date range,鑑定{0}為員工在給定日期範圍{1}創建
+Salary Slips Created,工資單創建
+Expected Discharge,預期解僱
+Del,刪除
+Campaign Naming By,活動命名由
+Current Address Is,當前地址是
+Monthly Sales Target (,每月銷售目標（
+Identification Document Number,身份證明文件號碼
+"Optional. Sets company's default currency, if not specified.",可選。設置公司的默認貨幣，如果沒有指定。
+Customer GSTIN,客戶GSTIN,
+List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,在現場檢測到的疾病清單。當選擇它會自動添加一個任務清單處理疾病
+This is a root healthcare service unit and cannot be edited.,這是根醫療保健服務單位，不能編輯。
+Repair Status,維修狀態
+Add Sales Partners,添加銷售合作夥伴
+Accounting journal entries.,會計日記帳分錄。
+Travel Request,旅行要求
+Available Qty at From Warehouse,可用數量從倉庫
+Please select Employee Record first.,請選擇員工記錄第一。
+Attendance not submitted for {0} as it is a Holiday.,由於是假期，因此未出席{0}的考勤。
+Account for Change Amount,帳戶漲跌額
+Connecting to QuickBooks,連接到QuickBooks,
+Total Gain/Loss,總收益/損失
+Invalid Company for Inter Company Invoice.,公司發票無效公司。
+input service,輸入服務
+Row {0}: Party / Account does not match with {1} / {2} in {3} {4},行{0}：甲方/客戶不與匹配{1} / {2} {3} {4}
+Employee Promotion,員工晉升
+Maintenance Team Member,維護團隊成員
+Course Code: ,課程編號：
+Please enter Expense Account,請輸入您的費用科目
+Stock,庫存
+"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry",行＃{0}：參考文件類型必須是採購訂單之一，購買發票或日記帳分錄
+Current Address,當前地址
+"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified",如果項目是另一項目，然後描述，圖像，定價，稅費等會從模板中設定的一個變體，除非明確指定
+Purchase / Manufacture Details,採購／製造詳細資訊
+Assessment Group,評估小組
+Batch Inventory,批量庫存
+GST Transporter ID,消費稅轉運ID,
+Procedure Name,程序名稱
+Contract End Date,合同結束日期
+Seller ID,賣家ID,
+Track this Sales Order against any Project,跟踪對任何項目這個銷售訂單
+Bank Statement Transaction Entry,銀行對賬單交易分錄
+Discount and Margin,折扣和保證金
+Prescription,處方
+Default Deferred Revenue Account,默認遞延收入科目
+Second Email,第二封郵件
+Action if Annual Budget Exceeded on Actual,年度預算超出實際的行動
+Min Qty,最小數量
+Planned Qty,計劃數量
+Date of Incorporation,註冊成立日期
+Total Tax,總稅收
+Last Purchase Price,上次購買價格
+For Quantity (Manufactured Qty) is mandatory,對於數量（製造數量）是強制性的
+Default Target Warehouse,預設目標倉庫
+Net Total (Company Currency),總淨值（公司貨幣）
+Air,空氣
+The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,年末日期不能超過年度開始日期。請更正日期，然後再試一次。
+{0} is not in Optional Holiday List,{0}不在可選節日列表中
+Purchase Receipt Message,採購入庫單訊息
+Scrap Items,廢物品
+Actual Start Date,實際開始日期
+% of materials delivered against this Sales Order,針對這張銷售訂單的已交貨物料的百分比(%)
+Generate Material Requests (MRP) and Work Orders.,生成材料請求（MRP）和工作訂單。
+Set default mode of payment,設置默認付款方式
+With Operations,加入作業
+Post Route Key List,發布路由密鑰列表
+Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,會計分錄已取得貨幣{0}為公司{1}。請選擇一個應收或應付科目幣種{0}。
+Is Existing Asset,是對現有資產
+Statistical Component,統計組成部分
+Statistical Component,統計組成部分
+If different than customer address,如果與客戶地址不同
+Without Payment of Tax,不繳納稅款
+BOM Operation,BOM的操作
+On Previous Row Amount,在上一行金額
+Has Expiry Date,有過期日期
+Transfer Asset,轉讓資產
+POS Profile,POS簡介
+Event Name,事件名稱
+Phone (Office),電話（辦公室）
+"Cannot Submit, Employees left to mark attendance",無法提交，僱員留下來標記出席
+Admission,入場
+Admissions for {0},招生{0}
+"Seasonality for setting budgets, targets etc.",季節性設置預算，目標等。
+Variable Name,變量名
+"Item {0} is a template, please select one of its variants",項目{0}是一個模板，請選擇它的一個變體
+Deferred Expense,遞延費用
+From Date {0} cannot be before employee's joining Date {1},起始日期{0}不能在員工加入日期之前{1}
+Asset Category,資產類別
+Net pay cannot be negative,淨工資不能為負
+Advance Paid,提前支付
+Overproduction Percentage For Sales Order,銷售訂單超額生產百分比
+Item Tax,產品稅
+Material to Supplier,材料到供應商
+Material Request Planning,物料請求計劃
+Excise Invoice,消費稅發票
+Treshold {0}% appears more than once,Treshold {0}出現％不止一次
+Employees Email Id,員工的電子郵件ID,
+Marked Attendance,明顯考勤
+Current Liabilities,流動負債
+Timer exceeded the given hours.,計時器超出了指定的小時數
+Send mass SMS to your contacts,發送群發短信到您的聯絡人
+A Positive,積極的
+Program Name,程序名稱
+Consider Tax or Charge for,考慮稅收或收費
+Driving License Category,駕駛執照類別
+Actual Qty is mandatory,實際數量是強制性
+"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0}目前擁有{1}供應商記分卡，而採購訂單應謹慎提供給供應商。
+Asset Maintenance Team,資產維護團隊
+Loan Type,貸款類型
+Scheduling Tool,調度工具
+Item to be manufactured or repacked,產品被製造或重新包裝
+Syntax error in condition: {0},條件中的語法錯誤：{0}
+Major/Optional Subjects,大/選修課
+Please Set Supplier Group in Buying Settings.,請設置供應商組購買設置。
+"Total flexible benefit component amount {0} should not be less \
 				than max benefits {1}",靈活福利組件總額{0}不應低於最大福利{1}
-DocType: Sales Invoice Item,Drop Ship,直接發運給客戶
-DocType: Driver,Suspended,暫停
-DocType: Training Event,Attendees,與會者
-DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children",在這裡，您可以維護家庭的詳細訊息，如父母，配偶和子女的姓名及職業
-DocType: Academic Term,Term End Date,期限結束日期
-DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),稅收和扣除（公司貨幣）
-DocType: Item Group,General Settings,一般設定
-apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23,From Currency and To Currency cannot be same,原始貨幣和目標貨幣不能相同
-DocType: Taxable Salary Slab,Percent Deduction,扣除百分比
-DocType: Stock Entry,Repack,重新包裝
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,在繼續之前，您必須儲存表單
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +125,Please select the Company first,請先選擇公司
-DocType: Item Attribute,Numeric Values,數字值
-apps/erpnext/erpnext/public/js/setup_wizard.js +56,Attach Logo,附加標誌
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +51,Stock Levels,庫存水平
-DocType: Customer,Commission Rate,佣金比率
-apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py +241,Successfully created payment entries,成功創建付款條目
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187,Created {0} scorecards for {1} between: ,為{1}創建{0}記分卡：
-apps/erpnext/erpnext/stock/doctype/item/item.js +590,Make Variant,在Variant
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +156,"Payment Type must be one of Receive, Pay and Internal Transfer",付款方式必須是接收之一，收費和內部轉賬
-DocType: Travel Itinerary,Preferred Area for Lodging,住宿的首選地區
-apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25,Cart is Empty,車是空的
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +430,"Item {0} has no Serial No. Only serilialized items \
+Drop Ship,直接發運給客戶
+Suspended,暫停
+Attendees,與會者
+"Here you can maintain family details like name and occupation of parent, spouse and children",在這裡，您可以維護家庭的詳細訊息，如父母，配偶和子女的姓名及職業
+Term End Date,期限結束日期
+Taxes and Charges Deducted (Company Currency),稅收和扣除（公司貨幣）
+General Settings,一般設定
+From Currency and To Currency cannot be same,原始貨幣和目標貨幣不能相同
+Percent Deduction,扣除百分比
+Repack,重新包裝
+You must Save the form before proceeding,在繼續之前，您必須儲存表單
+Please select the Company first,請先選擇公司
+Numeric Values,數字值
+Attach Logo,附加標誌
+Stock Levels,庫存水平
+Commission Rate,佣金比率
+Successfully created payment entries,成功創建付款條目
+Created {0} scorecards for {1} between: ,為{1}創建{0}記分卡：
+Make Variant,在Variant,
+"Payment Type must be one of Receive, Pay and Internal Transfer",付款方式必須是接收之一，收費和內部轉賬
+Preferred Area for Lodging,住宿的首選地區
+Cart is Empty,車是空的
+"Item {0} has no Serial No. Only serilialized items \
 						can have delivery based on Serial No",項目{0}沒有序列號只有serilialized items \可以根據序列號進行交付
-DocType: Work Order,Actual Operating Cost,實際運行成本
-DocType: Payment Entry,Cheque/Reference No,支票/參考編號
-DocType: Soil Texture,Clay Loam,粘土Loam
-apps/erpnext/erpnext/accounts/doctype/account/account.py +88,Root cannot be edited.,root不能被編輯。
-DocType: Item,Units of Measure,測量的單位
-DocType: Supplier,Default Tax Withholding Config,預設稅款預扣配置
-DocType: Manufacturing Settings,Allow Production on Holidays,允許假日生產
-DocType: Sales Invoice,Customer's Purchase Order Date,客戶的採購訂單日期
-DocType: Asset,Default Finance Book,默認金融書
-DocType: Shopping Cart Settings,Show Public Attachments,顯示公共附件
-apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js +3,Edit Publishing Details,編輯發布細節
-DocType: Packing Slip,Package Weight Details,包裝重量詳情
-DocType: Leave Type,Is Compensatory,是有補償的
-DocType: Restaurant Reservation,Reservation Time,預訂時間
-DocType: Payment Gateway Account,Payment Gateway Account,網路支付閘道科目
-DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,支付完成後重定向用戶選擇的頁面。
-DocType: Company,Existing Company,現有的公司
-DocType: Healthcare Settings,Result Emailed,電子郵件結果
-apps/erpnext/erpnext/controllers/buying_controller.py +101,"Tax Category has been changed to ""Total"" because all the Items are non-stock items",稅項類別已更改為“合計”，因為所有物品均為非庫存物品
-apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +35,To date can not be equal or less than from date,迄今為止不能等於或少於日期
-apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +118,Nothing to change,沒什麼可改變的
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +104,Please select a csv file,請選擇一個csv文件
-DocType: Holiday List,Total Holidays,總假期
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +123,Missing email template for dispatch. Please set one in Delivery Settings.,缺少發送的電子郵件模板。請在“傳遞設置”中設置一個。
-DocType: Student Leave Application,Mark as Present,標記為現
-DocType: Supplier Scorecard,Indicator Color,指示燈顏色
-DocType: Purchase Order,To Receive and Bill,準備收料及接收發票
-apps/erpnext/erpnext/controllers/buying_controller.py +691,Row #{0}: Reqd by Date cannot be before Transaction Date,行號{0}：按日期請求不能在交易日期之前
-apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,特色產品
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +384,Select Serial No,選擇序列號
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99,Designer,設計師
-apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,條款及細則範本
-DocType: Delivery Trip,Delivery Details,交貨細節
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +618,Cost Center is required in row {0} in Taxes table for type {1},成本中心是必需的行{0}稅表型{1}
-DocType: Program,Program Code,程序代碼
-DocType: Terms and Conditions,Terms and Conditions Help,條款和條件幫助
-,Item-wise Purchase Register,項目明智的購買登記
-DocType: Loyalty Point Entry,Expiry Date,到期時間
-DocType: Healthcare Settings,Employee name and designation in print,員工姓名和印刷品名稱
-,accounts-browser,科目瀏覽器
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +381,Please select Category first,請先選擇分類
-apps/erpnext/erpnext/config/projects.py +13,Project master.,專案主持。
-apps/erpnext/erpnext/controllers/status_updater.py +215,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.",要允許對賬單或過度訂貨，庫存設置或更新項目“津貼”。
-DocType: Contract,Contract Terms,合同條款
-DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,不要顯示如$等任何貨幣符號。
-apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +89,Maximum benefit amount of component {0} exceeds {1},組件{0}的最大受益金額超過{1}
-DocType: Payment Term,Credit Days,信貸天
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +140,Please select Patient to get Lab Tests,請選擇患者以獲得實驗室測試
-apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,讓學生批
-DocType: BOM Explosion Item,Allow Transfer for Manufacture,允許轉移製造
-DocType: Leave Type,Is Carry Forward,是弘揚
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +997,Get Items from BOM,從物料清單取得項目
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,交貨期天
-DocType: Cash Flow Mapping,Is Income Tax Expense,是所得稅費用
-apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py +19,Your order is out for delivery!,您的訂單已發貨！
-apps/erpnext/erpnext/controllers/accounts_controller.py +693,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},行＃{0}：過帳日期必須是相同的購買日期{1}資產的{2}
-DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,如果學生住在學院的旅館，請檢查。
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125,Please enter Sales Orders in the above table,請在上表中輸入銷售訂單
-,Stock Summary,庫存摘要
-apps/erpnext/erpnext/config/assets.py +62,Transfer an asset from one warehouse to another,從一個倉庫轉移資產到另一
-DocType: Employee Benefit Application,Remaining Benefits (Yearly),剩餘福利（每年）
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +873,Bill of Materials,材料清單
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +137,Row {0}: Party Type and Party is required for Receivable / Payable account {1},行{0}：參與方類型和參與方需要應收/應付科目{1}
-DocType: Employee,Leave Policy,離開政策
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +865,Update Items,更新項目
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94,Ref Date,參考日期
-DocType: Employee,Reason for Leaving,離職原因
-DocType: BOM Operation,Operating Cost(Company Currency),營業成本（公司貨幣）
-DocType: Expense Claim Detail,Sanctioned Amount,制裁金額
-DocType: Item,Shelf Life In Days,保質期天數
-DocType: GL Entry,Is Opening,是開幕
-DocType: Department,Expense Approvers,費用審批人
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +228,Row {0}: Debit entry can not be linked with a {1},行{0}：借方條目不能與{1}連接
-DocType: Journal Entry,Subscription Section,認購科
-apps/erpnext/erpnext/accounts/doctype/account/account.py +238,Account {0} does not exist,科目{0}不存在
-DocType: Training Event,Training Program,培訓計劃
-DocType: Account,Cash,現金
-DocType: Employee,Short biography for website and other publications.,網站和其他出版物的短的傳記。
+Actual Operating Cost,實際運行成本
+Cheque/Reference No,支票/參考編號
+Clay Loam,粘土Loam,
+Root cannot be edited.,root不能被編輯。
+Units of Measure,測量的單位
+Default Tax Withholding Config,預設稅款預扣配置
+Allow Production on Holidays,允許假日生產
+Customer's Purchase Order Date,客戶的採購訂單日期
+Default Finance Book,默認金融書
+Show Public Attachments,顯示公共附件
+Edit Publishing Details,編輯發布細節
+Package Weight Details,包裝重量詳情
+Is Compensatory,是有補償的
+Reservation Time,預訂時間
+Payment Gateway Account,網路支付閘道科目
+After payment completion redirect user to selected page.,支付完成後重定向用戶選擇的頁面。
+Existing Company,現有的公司
+Result Emailed,電子郵件結果
+"Tax Category has been changed to ""Total"" because all the Items are non-stock items",稅項類別已更改為“合計”，因為所有物品均為非庫存物品
+To date can not be equal or less than from date,迄今為止不能等於或少於日期
+Nothing to change,沒什麼可改變的
+Please select a csv file,請選擇一個csv文件
+Total Holidays,總假期
+Missing email template for dispatch. Please set one in Delivery Settings.,缺少發送的電子郵件模板。請在“傳遞設置”中設置一個。
+Mark as Present,標記為現
+Indicator Color,指示燈顏色
+To Receive and Bill,準備收料及接收發票
+Row #{0}: Reqd by Date cannot be before Transaction Date,行號{0}：按日期請求不能在交易日期之前
+Featured Products,特色產品
+Select Serial No,選擇序列號
+Designer,設計師
+Terms and Conditions Template,條款及細則範本
+Delivery Details,交貨細節
+Cost Center is required in row {0} in Taxes table for type {1},成本中心是必需的行{0}稅表型{1}
+Program Code,程序代碼
+Terms and Conditions Help,條款和條件幫助
+Item-wise Purchase Register,項目明智的購買登記
+Expiry Date,到期時間
+Employee name and designation in print,員工姓名和印刷品名稱
+accounts-browser,科目瀏覽器
+Please select Category first,請先選擇分類
+Project master.,專案主持。
+"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.",要允許對賬單或過度訂貨，庫存設置或更新項目“津貼”。
+Contract Terms,合同條款
+Do not show any symbol like $ etc next to currencies.,不要顯示如$等任何貨幣符號。
+Maximum benefit amount of component {0} exceeds {1},組件{0}的最大受益金額超過{1}
+Credit Days,信貸天
+Please select Patient to get Lab Tests,請選擇患者以獲得實驗室測試
+Make Student Batch,讓學生批
+Allow Transfer for Manufacture,允許轉移製造
+Is Carry Forward,是弘揚
+Get Items from BOM,從物料清單取得項目
+Lead Time Days,交貨期天
+Is Income Tax Expense,是所得稅費用
+Your order is out for delivery!,您的訂單已發貨！
+Row #{0}: Posting Date must be same as purchase date {1} of asset {2},行＃{0}：過帳日期必須是相同的購買日期{1}資產的{2}
+Check this if the Student is residing at the Institute's Hostel.,如果學生住在學院的旅館，請檢查。
+Please enter Sales Orders in the above table,請在上表中輸入銷售訂單
+Stock Summary,庫存摘要
+Transfer an asset from one warehouse to another,從一個倉庫轉移資產到另一
+Remaining Benefits (Yearly),剩餘福利（每年）
+Bill of Materials,材料清單
+Row {0}: Party Type and Party is required for Receivable / Payable account {1},行{0}：參與方類型和參與方需要應收/應付科目{1}
+Leave Policy,離開政策
+Update Items,更新項目
+Ref Date,參考日期
+Reason for Leaving,離職原因
+Operating Cost(Company Currency),營業成本（公司貨幣）
+Sanctioned Amount,制裁金額
+Shelf Life In Days,保質期天數
+Is Opening,是開幕
+Expense Approvers,費用審批人
+Row {0}: Debit entry can not be linked with a {1},行{0}：借方條目不能與{1}連接
+Subscription Section,認購科
+Account {0} does not exist,科目{0}不存在
+Training Program,培訓計劃
+Cash,現金
+Short biography for website and other publications.,網站和其他出版物的短的傳記。
