DocType: Employee,Salary Mode,Pajamos režimas
apps/erpnext/erpnext/hub_node/page/hub/hub.js +67,Register,Registruotis
DocType: Patient,Divorced,išsiskyręs
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Leisti punktas turi būti pridėtas kelis kartus iš sandorio
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Atšaukti medžiaga Apsilankymas {0} prieš panaikinant šį garantinės pretenzijos
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19,Consumer Products,Vartotojų gaminiai
DocType: Purchase Receipt,Subscription Detail,Prenumeratos informacija
DocType: Supplier Scorecard,Notify Supplier,Pranešti tiekėjui
DocType: Item,Customer Items,klientų daiktai
DocType: Project,Costing and Billing,Sąnaudų ir atsiskaitymas
apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: Parent account {1} can not be a ledger,Sąskaita {0}: Tėvų sąskaitą {1} negali būti knygos
DocType: Item,Publish Item to hub.erpnext.com,Paskelbti Prekę hub.erpnext.com
apps/erpnext/erpnext/config/setup.py +88,Email Notifications,Siųsti Pranešimai
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26,Evaluation,vertinimas
DocType: Item,Default Unit of Measure,Numatytasis matavimo vienetas
DocType: SMS Center,All Sales Partner Contact,Visos pardavimo partnerė Susisiekite
DocType: Employee,Leave Approvers,Palikite Approvers
DocType: Sales Partner,Dealer,prekiautojas
DocType: Consultation,Investigations,Tyrimai
DocType: Restaurant Order Entry,Click Enter To Add,Spustelėkite &quot;Įtraukti&quot;
DocType: Employee,Rented,nuomojamos
DocType: Purchase Order,PO-,po-
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +216,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Sustabdyta Gamybos nurodymas negali būti atšauktas, atkišti ji pirmą kartą atšaukti"
DocType: Vehicle Service,Mileage,Rida
apps/erpnext/erpnext/assets/doctype/asset/asset.js +240,Do you really want to scrap this asset?,Ar tikrai norite atsisakyti šios turtą?
DocType: Drug Prescription,Update Schedule,Atnaujinti tvarkaraštį
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44,Select Default Supplier,Pasirinkti Default Tiekėjas
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37,Currency is required for Price List {0},Valiutų reikia kainoraščio {0}
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Bus apskaičiuojama sandorį.
DocType: Purchase Order,Customer Contact,Klientų Susisiekite
DocType: Patient Appointment,Check availability,Patikrinkite užimtumą
DocType: Job Applicant,Job Applicant,Darbas Pareiškėjas
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,Tai grindžiama sandorių atžvilgiu šis tiekėjas. Žiūrėti grafikas žemiau detales
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120,Legal,juridinis
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191,Actual type tax cannot be included in Item rate in row {0},Tikrasis tipas mokestis negali būti įtrauktos prekės lygis eilės {0}
DocType: Bank Guarantee,Customer,klientas
DocType: Purchase Receipt Item,Required By,reikalaujama pagal
DocType: Delivery Note,Return Against Delivery Note,Grįžti Prieš važtaraštyje
DocType: Purchase Order,% Billed,% Įvardintas
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43,Exchange Rate must be same as {0} {1} ({2}),"Valiutų kursai turi būti toks pat, kaip {0} {1} ({2})"
DocType: Sales Invoice,Customer Name,Klientas
DocType: Vehicle,Natural Gas,Gamtinių dujų
apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64,Bank account cannot be named as {0},Banko sąskaita negali būti vadinamas {0}
DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,"Vadovai (ar jų grupės), pagal kurį apskaitos įrašai yra pagaminti ir likučiai išlieka."
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196,Outstanding for {0} cannot be less than zero ({1}),Neįvykdyti {0} negali būti mažesnė už nulį ({1})
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +343,There are no submitted Salary Slips to process.,Apdorojimo atlyginimo užstatas nėra.
DocType: Manufacturing Settings,Default 10 mins,Numatytasis 10 min
DocType: Leave Type,Leave Type Name,Palikite Modelio pavadinimas
apps/erpnext/erpnext/templates/pages/projects.js +62,Show open,Rodyti atvira
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8,It is necessary to take this action today itself for the above mentioned recurring,Šiuos veiksmus reikia pačiam patys imtis pirmiau minėtuose pasikartojančiuose veiksmuose
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +151,Series Updated Successfully,Serija Atnaujinta sėkmingai
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +18,Checkout,Užsakymas
DocType: Pricing Rule,Apply On,taikyti ant
DocType: Item Price,Multiple Item prices.,Keli punktas kainos.
,Purchase Order Items To Be Received,Pirkimui užsakyti prekes bus gauta
DocType: SMS Center,All Supplier Contact,Visi tiekėju Kontaktai Reklama
DocType: Support Settings,Support Settings,paramos Nustatymai
apps/erpnext/erpnext/projects/doctype/project/project.py +72,Expected End Date can not be less than Expected Start Date,Tikimasi Pabaigos data negali būti mažesnė nei planuotos datos
apps/erpnext/erpnext/utilities/transaction_base.py +115,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,"Eilutės # {0}: dydis turi būti toks pat, kaip {1} {2} ({3} / {4})"
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +282,New Leave Application,Nauja atostogos taikymas
,Batch Item Expiry Status,Serija punktas Galiojimo Būsena
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184,Bank Draft,bankas projektas
DocType: Membership,membership validaty section,narystės patvirtinantis skyrius
DocType: Mode of Payment Account,Mode of Payment Account,mokėjimo sąskaitos režimas
DocType: Consultation,Consultation,Konsultacijos
DocType: Accounts Settings,Show Payment Schedule in Print,Rodyti mokėjimo grafiką Spausdinti
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19,Sales and Returns,Pardavimai ir grąžinimai
apps/erpnext/erpnext/stock/doctype/item/item.js +56,Show Variants,Rodyti Variantai
DocType: Academic Term,Academic Term,akademinė terminas
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,medžiaga
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66,Making website,Svetainės kūrimas
DocType: Opening Invoice Creation Tool Item,Quantity,kiekis
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +544,Accounts table cannot be blank.,Sąskaitos lentelė gali būti tuščias.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154,Loans (Liabilities),Paskolos (įsipareigojimai)
DocType: Employee Education,Year of Passing,Metus artimųjų
DocType: Item,Country of Origin,Kilmės šalis
DocType: Soil Texture,Soil Texture Criteria,Dirvožemio tekstūros kriterijai
apps/erpnext/erpnext/templates/includes/product_page.js +24,In Stock,Prekyboje
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16,Primary Contact Details,Pagrindinė kontaktinė informacija
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,Atviri klausimai
DocType: Production Plan Item,Production Plan Item,Gamybos planas punktas
apps/erpnext/erpnext/hr/doctype/employee/employee.py +149,User {0} is already assigned to Employee {1},Vartotojas {0} jau priskirtas Darbuotojo {1}
DocType: Lab Test Groups,Add new line,Pridėti naują eilutę
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31,Health Care,Sveikatos apsauga
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,Delay in payment (Days),Delsimas mokėjimo (dienomis)
DocType: Payment Terms Template Detail,Payment Terms Template Detail,Apmokėjimo sąlygos Šablono detalės
DocType: Lab Prescription,Lab Prescription,Lab receptas
apps/erpnext/erpnext/hub_node/page/hub/hub.js +185,Sort by Price,Rūšiuoti pagal kainą
,Delay Days,Vėlavimo dienos
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26,Service Expense,Paslaugų išlaidų
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +886,Serial Number: {0} is already referenced in Sales Invoice: {1},Serijos numeris: {0} jau yra nuorodos į pardavimo sąskaita-faktūra: {1}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +878,Invoice,faktūra
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +109,Make Retention Stock Entry,Padarykite atsargų įrašą
DocType: Purchase Invoice Item,Item Weight Details,Prekės svarumo duomenys
DocType: Asset Maintenance Log,Periodicity,periodiškumas
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Finansiniai metai {0} reikalingas
DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,Mažiausias atstumas tarp augalų eilučių siekiant optimalaus augimo
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21,Defense,apsauga
DocType: Salary Component,Abbr,abbr
DocType: Appraisal Goal,Score (0-5),Rezultatas (0-5)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +223,Row {0}: {1} {2} does not match with {3},Eilutės {0}: {1} {2} nesutampa su {3}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +77,Row # {0}:,Eilutės # {0}:
DocType: Timesheet,Total Costing Amount,Iš viso Sąnaudų suma
DocType: Delivery Note,Vehicle No,Automobilio Nėra
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +160,Please select Price List,Prašome pasirinkti Kainoraštis
DocType: Accounts Settings,Currency Exchange Settings,Valiutos keitimo nustatymai
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +78,Row #{0}: Payment document is required to complete the trasaction,Eilutės # {0}: mokėjimo dokumentas privalo baigti trasaction
DocType: Production Order Operation,Work In Progress,Darbas vyksta
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13,Please select date,Prašome pasirinkti datą
DocType: Employee,Holiday List,Atostogų sąrašas
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127,Accountant,buhalteris
DocType: Hub Settings,Selling Price List,Pardavimo kainoraštis
DocType: Patient,Tobacco Current Use,Tabako vartojimas
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +56,Selling Rate,Pardavimo norma
DocType: Cost Center,Stock User,akcijų Vartotojas
DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
DocType: Company,Phone No,Telefonas Nėra
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +237,New {0}: #{1},Nauja {0}: # {1}
DocType: Delivery Trip,Initial Email Notification Sent,Išsiunčiamas pradinis el. Pašto pranešimas
,Sales Partners Commission,Pardavimų Partneriai Komisija
DocType: Soil Texture,Sandy Clay Loam,Smėlio molio nuosėdos
DocType: Purchase Invoice,Rounding Adjustment,Apvalinimo reguliavimas
apps/erpnext/erpnext/setup/doctype/company/company.py +45,Abbreviation cannot have more than 5 characters,Santrumpa negali turėti daugiau nei 5 simboliai
DocType: Physician Schedule Time Slot,Physician Schedule Time Slot,Gydytojo tvarkaraščio laiko tarpsnis
DocType: Payment Request,Payment Request,mokėjimo prašymas
DocType: Asset,Value After Depreciation,Vertė po nusidėvėjimo
DocType: Student,O+,O +
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt_dashboard.py +18,Related,Susijęs
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43,Attendance date can not be less than employee's joining date,"Lankomumas data negali būti mažesnė nei darbuotojo, jungiančia datos"
DocType: Grading Scale,Grading Scale Name,Vertinimo skalė Vardas
DocType: Subscription,Repeat on Day,Pakartokite dieną
apps/erpnext/erpnext/accounts/doctype/account/account.js +41,This is a root account and cannot be edited.,Tai šaknys sąskaita ir negali būti redaguojami.
DocType: Sales Invoice,Company Address,Kompanijos adresas
DocType: BOM,Operations,operacijos
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38,Cannot set authorization on basis of Discount for {0},Negalima nustatyti leidimo pagrindu Nuolaida {0}
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Prisegti .csv failą su dviem stulpeliais, po vieną seną pavadinimą ir vieną naują vardą"
apps/erpnext/erpnext/accounts/utils.py +73,{0} {1} not in any active Fiscal Year.,{0} {1} jokiu aktyviu finansinius metus.
DocType: Packed Item,Parent Detail docname,Tėvų Išsamiau DOCNAME
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: {0}, Item Code: {1} and Customer: {2}","Nuoroda: {0}, Prekės kodas: {1} ir klientų: {2}"
apps/erpnext/erpnext/utilities/user_progress.py +143,Kg,Kilogramas
apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Atidarymo dėl darbo.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +110,BOM is not specified for subcontracting item {0} at row {1},BOM nėra nurodyta subrangos elementui {0} eilutėje {1}
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149,{0} Result submittted,{0} Rezultatų pateikimas
DocType: Item Attribute,Increment,prieaugis
apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +61,Timespan,Laiko tarpas
apps/erpnext/erpnext/public/js/stock_analytics.js +61,Select Warehouse...,Pasirinkite sandėlio ...
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6,Advertising,reklaminis
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,Pati bendrovė yra įrašytas daugiau nei vieną kartą
DocType: Patient,Married,Vedęs
apps/erpnext/erpnext/accounts/party.py +44,Not permitted for {0},Neleidžiama {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593,Get items from,Gauk elementus iš
DocType: Price List,Price Not UOM Dependant,Kaina ne priklausomai nuo UOM
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +454,Stock cannot be updated against Delivery Note {0},"Akcijų, negali būti atnaujintas prieš važtaraštyje {0}"
apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Prekės {0}
apps/erpnext/erpnext/templates/generators/item_group.html +43,No items listed,Nėra išvardytus punktus
DocType: Asset Repair,Error Description,Klaida Aprašymas
DocType: Payment Reconciliation,Reconcile,suderinti
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30,Grocery,Parduotuvė
DocType: Quality Inspection Reading,Reading 1,Skaitymas 1
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40,Pension Funds,pensijų fondai
apps/erpnext/erpnext/assets/doctype/asset/asset.py +91,Next Depreciation Date cannot be before Purchase Date,Kitas Nusidėvėjimas data negali būti prieš perkant data
DocType: Crop,Perennial,Daugiametis
DocType: Consultation,Consultation Date,Konsultacijos data
apps/erpnext/erpnext/hub_node/page/hub/hub.js +131,Product listing and discovery for ERPNext users,Produktų sąrašas ir atradimas ERPNext vartotojams
DocType: SMS Center,All Sales Person,Visi pardavimo asmuo
DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"** Mėnesio pasiskirstymas ** Jums padės platinti biudžeto / target visoje mėnesius, jei turite sezoniškumą savo verslą."
apps/erpnext/erpnext/accounts/page/pos/pos.js +1743,Not items found,Nerasta daiktai
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183,Salary Structure Missing,Darbo užmokesčio struktūrą Trūksta
DocType: Lead,Person Name,"asmens vardas, pavardė"
DocType: Sales Invoice Item,Sales Invoice Item,Pardavimų sąskaita faktūra punktas
DocType: Account,Credit,kreditas
DocType: POS Profile,Write Off Cost Center,Nurašyti išlaidų centrus
apps/erpnext/erpnext/public/js/setup_wizard.js +117,"e.g. ""Primary School"" or ""University""",pvz &quot;pradinė mokykla&quot; arba &quot;Universitetas&quot;
apps/erpnext/erpnext/config/stock.py +28,Stock Reports,Akcijų ataskaitos
DocType: Warehouse,Warehouse Detail,Sandėlių detalės
apps/erpnext/erpnext/selling/doctype/customer/customer.py +193,Credit limit has been crossed for customer {0} {1}/{2},Kredito limitas buvo kirto klientui {0} {1} / {2}
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.,"Kadencijos pabaigos data negali būti vėlesnė nei metų pabaigoje mokslo metų data, iki kurios terminas yra susijęs (akademiniai metai {}). Ištaisykite datas ir bandykite dar kartą."
apps/erpnext/erpnext/stock/doctype/item/item.py +258,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","&quot;Ar Ilgalaikio turto&quot; negali būti nepažymėta, kaip Turto įrašas egzistuoja nuo elemento"
DocType: Delivery Trip,Departure Time,Išvykimo laikas
DocType: Vehicle Service,Brake Oil,stabdžių Nafta
DocType: Tax Rule,Tax Type,mokesčių tipas
apps/erpnext/erpnext/controllers/taxes_and_totals.py +568,Taxable Amount,apmokestinamoji vertė
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160,You are not authorized to add or update entries before {0},Jūs nesate įgaliotas pridėti ar atnaujinti įrašus prieš {0}
DocType: BOM,Item Image (if not slideshow),Prekė vaizdas (jei ne skaidrių)
DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Valandą greičiu / 60) * Tikrasis veikimo laikas
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1076,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Eilutė # {0}: standartinio dokumento tipas turi būti vienas iš išlaidų reikalavimo arba leidimo įrašo
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +964,Select BOM,Pasirinkite BOM
DocType: SMS Log,SMS Log,SMS Prisijungti
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Išlaidos pristatyto objekto
apps/erpnext/erpnext/config/hr.py +127,Manage advance amount given to the Employee,Tvarkyti darbuotojui skirtą išankstinę sumą
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38,The holiday on {0} is not between From Date and To Date,Atostogų į {0} yra ne tarp Nuo datos ir iki šiol
DocType: Student Log,Student Log,Studentų Prisijungti
DocType: Quality Inspection,Get Specification Details,Gauk specifikaciją
apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Tiekėjo lentelės šablonai.
DocType: Lead,Interested,Suinteresuotas
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +191,Opening,atidarymas
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +30,From {0} to {1},Iš {0} ir {1}
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50,Failed to setup taxes,Nepavyko nustatyti mokesčių
DocType: Item,Copy From Item Group,Kopijuoti Nuo punktas grupės
DocType: Delivery Trip,Delivery Notification,Pristatymo pranešimas
DocType: Journal Entry,Opening Entry,atidarymas įrašas
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Sąskaita mokate tik
DocType: Employee Loan,Repay Over Number of Periods,Grąžinti Over periodų skaičius
DocType: Stock Entry,Additional Costs,Papildomos išlaidos
apps/erpnext/erpnext/accounts/doctype/account/account.py +138,Account with existing transaction can not be converted to group.,Sąskaita su esama sandoris negali būti konvertuojamos į grupę.
DocType: Lead,Product Enquiry,Prekės Užklausa
DocType: Education Settings,Validate Batch for Students in Student Group,Patvirtinti Serija studentams Studentų grupės
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,No leave record found for employee {0} for {1},Ne atostogos rekordas darbuotojo rado {0} už {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23,Please enter company first,Prašome įvesti įmonę pirmas
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366,Please select Company first,Prašome pasirinkti Company pirmas
DocType: Employee Education,Under Graduate,pagal diplomas
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,Tikslinė Apie
DocType: BOM,Total Cost,Iš viso išlaidų
DocType: Soil Analysis,Ca/K,Ca / K
DocType: Journal Entry Account,Employee Loan,Darbuotojų Paskolos
DocType: Fee Schedule,Send Payment Request Email,Siųsti mokėjimo užklausą el. Paštu
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +259,Item {0} does not exist in the system or has expired,Prekė {0} sistemoje neegzistuoja arba pasibaigė galiojimas
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44,Real Estate,Nekilnojamasis turtas
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Sąskaitų ataskaita
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41,Pharmaceuticals,vaistai
DocType: Purchase Invoice Item,Is Fixed Asset,Ar Ilgalaikio turto
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +256,"Available qty is {0}, you need {1}","Turimas Kiekis yra {0}, jums reikia {1}"
DocType: Expense Claim Detail,Claim Amount,reikalavimo suma
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56,Duplicate customer group found in the cutomer group table,rasti abonentu grupės lentelėje dublikatas klientų grupė
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Type / Supplier,Tiekėjas Tipas / Tiekėjas
DocType: Naming Series,Prefix,priešdėlis
apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7,Event Location,Renginio vieta
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68,Consumable,vartojimo
DocType: Student,B-,B
DocType: Production Planning Tool,Pull Material Request of type Manufacture based on the above criteria,Ištraukite Material prašymu tipo Gamyba remiantis pirmiau minėtais kriterijais
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +100,Successfully unregistered.,Sėkmingai neįregistruota.
DocType: Assessment Result,Grade,klasė
DocType: Restaurant Table,No of Seats,Sėdimų vietų skaičius
DocType: Subscription,"To add dynamic subject, use jinja tags like

<div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>","Norėdami pridėti dinaminį temą, naudokite jinja žymes kaip <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>"
DocType: Sales Invoice Item,Delivered By Supplier,Paskelbta tiekėjo
DocType: Asset Maintenance Task,Asset Maintenance Task,Turto išlaikymo užduotis
DocType: SMS Center,All Contact,visi Susisiekite
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +952,Production Order already created for all items with BOM,Gamybos Užsakyti jau sukurtas visų daiktų su BOM
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +230,Annual Salary,Metinis atlyginimas
DocType: Daily Work Summary,Daily Work Summary,Dienos darbo santrauka
DocType: Period Closing Voucher,Closing Fiscal Year,Uždarius finansinius metus
apps/erpnext/erpnext/accounts/party.py +380,{0} {1} is frozen,{0} {1} yra sušaldyti
apps/erpnext/erpnext/setup/doctype/company/company.py +136,Please select Existing Company for creating Chart of Accounts,Prašome pasirinkti veikiančią bendrovę kurti sąskaitų planą
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80,Stock Expenses,Akcijų išlaidos
apps/erpnext/erpnext/stock/doctype/batch/batch.js +103,Select Target Warehouse,Pasirinkite Target sandėlis
apps/erpnext/erpnext/stock/doctype/batch/batch.js +103,Select Target Warehouse,Pasirinkite Target sandėlis
apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,Prašome įvesti Pageidautina kontaktinį elektroninio pašto adresą
DocType: Journal Entry,Contra Entry,contra įrašas
DocType: Journal Entry Account,Credit in Company Currency,Kredito įmonėje Valiuta
DocType: Lab Test UOM,Lab Test UOM,Lab Test UOM
DocType: Delivery Note,Installation Status,Įrengimas būsena
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135,"Do you want to update attendance?<br>Present: {0}\
					<br>Absent: {1}",Norite atnaujinti lankomumą? <br> Dovana: {0} \ <br> Nėra: {1}
apps/erpnext/erpnext/controllers/buying_controller.py +344,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Priimamos + Atmesta Kiekis turi būti lygi Gauta kiekio punktui {0}
DocType: Request for Quotation,RFQ-,RFQ-
DocType: Item,Supply Raw Materials for Purchase,Tiekimo Žaliavos pirkimas
DocType: Agriculture Analysis Criteria,Fertilizer,Trąšų
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +150,At least one mode of payment is required for POS invoice.,Bent vienas režimas mokėjimo reikalingas POS sąskaitą.
DocType: Products Settings,Show Products as a List,Rodyti produktus sąraše
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +512,Item {0} is not active or end of life has been reached,"Prekė {0} nėra aktyvus, ar buvo pasiektas gyvenimo pabaigos"
DocType: Student Admission Program,Minimum Age,Minimalus amžius
apps/erpnext/erpnext/utilities/user_progress.py +187,Example: Basic Mathematics,Pavyzdys: Elementarioji matematika
apps/erpnext/erpnext/controllers/accounts_controller.py +793,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Įtraukti mokestį iš eilės {0} prekės norma, mokesčiai eilučių {1}, taip pat turi būti įtraukti"
apps/erpnext/erpnext/config/hr.py +223,Settings for HR Module,Nustatymai HR modulio
DocType: SMS Center,SMS Center,SMS centro
DocType: Sales Invoice,Change Amount,Pakeisti suma
DocType: BOM Update Tool,New BOM,nauja BOM
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,Show only POS,Rodyti tik POS
DocType: Driver,Driving License Categories,Vairuotojo pažymėjimo kategorijos
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118,Please enter Delivery Date,Įveskite pristatymo datą
DocType: Depreciation Schedule,Make Depreciation Entry,Padaryti nusidėvėjimo įrašą
DocType: Appraisal Template Goal,KRA,KRA
DocType: Lead,Request Type,prašymas tipas
apps/erpnext/erpnext/hr/doctype/offer_letter/offer_letter.js +17,Make Employee,Padaryti Darbuotojas
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,transliavimas
apps/erpnext/erpnext/config/accounts.py +313,Setup mode of POS (Online / Offline),POS nustatymas (internetu / neprisijungus)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191,Execution,vykdymas
apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Išsami informacija apie atliktas operacijas.
DocType: Asset Maintenance Log,Maintenance Status,techninės priežiūros būseną
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10,Membership Details,Narystės duomenys
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Tiekėjas privalo prieš MOKĖTINOS sąskaitą {2}
apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Elementus ir kainodara
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},Iš viso valandų: {0}
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,From Date should be within the Fiscal Year. Assuming From Date = {0},Nuo data turėtų būti per finansinius metus. Darant prielaidą Iš data = {0}
DocType: Drug Prescription,Interval,Intervalas
DocType: Grant Application,Individual,individualus
DocType: Academic Term,Academics User,akademikai Vartotojas
DocType: Cheque Print Template,Amount In Figure,Suma pav
DocType: Employee Loan Application,Loan Info,paskolos informacija
apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Planas techninės priežiūros apsilankymų.
DocType: Supplier Scorecard Period,Supplier Scorecard Period,Tiekėjo rezultatų kortelės laikotarpis
DocType: POS Profile,Customer Groups,klientų Grupės
apps/erpnext/erpnext/public/js/financial_statements.js +51,Financial Statements,Finansinės ataskaitos
DocType: Guardian,Students,studentai
apps/erpnext/erpnext/config/selling.py +91,Rules for applying pricing and discount.,Taikymo taisyklės kainodaros ir nuolaida.
DocType: Physician Schedule,Time Slots,Laiko lizdai
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,Kainų sąrašas turi būti taikoma perkant ar parduodant
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79,Installation date cannot be before delivery date for Item {0},Montavimo data gali būti ne anksčiau pristatymo datos punkte {0}
DocType: Pricing Rule,Discount on Price List Rate (%),Nuolaida Kainų sąrašas tarifas (%)
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112,Item Template,Elemento šablonas
apps/erpnext/erpnext/healthcare/setup.py +215,Biochemistry,Biochemija
DocType: Offer Letter,Select Terms and Conditions,Pasirinkite Terminai ir sąlygos
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70,Out Value,iš Vertė
DocType: Production Planning Tool,Sales Orders,pardavimų užsakymai
DocType: Purchase Taxes and Charges,Valuation,įvertinimas
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +380,Set as Default,Nustatyti kaip numatytąją
,Purchase Order Trends,Pirkimui užsakyti tendencijos
apps/erpnext/erpnext/utilities/user_progress.py +75,Go to Customers,Eikite į klientus
apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,The request for quotation can be accessed by clicking on the following link,Už citatos prašymas gali būti atvertas paspaudę šią nuorodą
apps/erpnext/erpnext/config/hr.py +81,Allocate leaves for the year.,Skirti lapai per metus.
DocType: SG Creation Tool Course,SG Creation Tool Course,SG kūrimo įrankis kursai
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +258,Insufficient Stock,nepakankamas sandėlyje
DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Išjungti pajėgumų planavimas ir laiko sekimo
DocType: Email Digest,New Sales Orders,Naujų pardavimo užsakymus
DocType: Bank Guarantee,Bank Account,Banko sąskaita
DocType: Leave Type,Allow Negative Balance,Leiskite neigiamas balansas
apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',Negalite ištrinti projekto tipo &quot;Išorinis&quot;
DocType: Employee,Create User,Sukurti vartotoją
DocType: Selling Settings,Default Territory,numatytasis teritorija
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53,Television,televizija
DocType: Production Order Operation,Updated via 'Time Log',Atnaujinta per &quot;Time Prisijungti&quot;
apps/erpnext/erpnext/controllers/taxes_and_totals.py +428,Advance amount cannot be greater than {0} {1},Avanso suma gali būti ne didesnė kaip {0} {1}
DocType: Naming Series,Series List for this Transaction,Serija sąrašas šio sandorio
DocType: Company,Enable Perpetual Inventory,Įjungti nuolatinio inventorizavimo
DocType: Company,Default Payroll Payable Account,Numatytasis darbo užmokesčio mokamas paskyra
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51,Update Email Group,Atnaujinti paštas grupė
DocType: Sales Invoice,Is Opening Entry,Ar atidarymas įrašą
DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Jei nepažymėta, prekė bus neįtraukta į pardavimo sąskaitą, bet gali būti naudojama grupės bandymų kūrimui."
DocType: Customer Group,Mention if non-standard receivable account applicable,"Nurodyk, jei nestandartinis gautinos sąskaitos taikoma"
DocType: Course Schedule,Instructor Name,instruktorius Vardas
DocType: Supplier Scorecard,Criteria Setup,Kriterijų nustatymas
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +199,For Warehouse is required before Submit,Sandėliavimo reikalingas prieš Pateikti
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8,Received On,gautas
DocType: Sales Partner,Reseller,perpardavinėjimo
DocType: Codification Table,Medical Code,Medicinos kodeksas
DocType: Production Planning Tool,"If checked, Will include non-stock items in the Material Requests.","Jei pažymėta, apims ne atsargos medžiagoje prašymus."
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20,Please enter Company,Prašome įvesti Įmonės
DocType: Delivery Note Item,Against Sales Invoice Item,Prieš Pardavimų sąskaitos punktas
DocType: Agriculture Analysis Criteria,Linked Doctype,Susietas &quot;Doctype&quot;
,Production Orders in Progress,Gamybos užsakymai Progress
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +39,Net Cash from Financing,Grynieji pinigų srautai iš finansavimo
apps/erpnext/erpnext/accounts/page/pos/pos.js +2333,"LocalStorage is full , did not save","LocalStorage &quot;yra pilna, neišsaugojo"
DocType: Lead,Address & Contact,Adresas ir kontaktai
DocType: Leave Allocation,Add unused leaves from previous allocations,Pridėti nepanaudotas lapus iš ankstesnių paskirstymų
DocType: Sales Partner,Partner website,partnerio svetainė
DocType: Restaurant Order Entry,Add Item,Pridėti Prekę
DocType: Lab Test,Custom Result,Tinkintas rezultatas
DocType: Delivery Stop,Contact Name,Kontaktinis vardas
DocType: Course Assessment Criteria,Course Assessment Criteria,Žinoma vertinimo kriterijai
DocType: POS Customer Group,POS Customer Group,POS Klientų grupė
DocType: Land Unit,Land Unit describing various land assets,"Žemės skyrius, kuriame aprašomas įvairias žemės turtas"
DocType: Cheque Print Template,Line spacing for amount in words,Tarpai tarp eilučių ir suma žodžiais
DocType: Vehicle,Additional Details,Papildoma informacija
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Assessment Plan: ,Vertinimo planas:
apps/erpnext/erpnext/templates/generators/bom.html +85,No description given,Nėra aprašymo suteikta
apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,Užsisakyti įsigyti.
DocType: Lab Test,Submitted Date,Pateiktas data
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,"Tai grindžiama darbo laiko apskaitos žiniaraščiai, sukurtų prieš šį projektą"
DocType: Payment Term,Credit Months,Kredito mėnesiai
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409,Net Pay cannot be less than 0,Neto darbo užmokestis negali būti mažesnis už 0
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,"To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription","Norėdami sustabdyti pakartotinių klaidų pranešimų siuntimą iš sistemos, prenumeruojame lauką &quot;Išjungta&quot;"
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +224,Only the selected Leave Approver can submit this Leave Application,Tik pasirinktas atostogos Tvirtintojas gali pateikti šias atostogas taikymas
apps/erpnext/erpnext/hr/doctype/employee/employee.py +121,Relieving Date must be greater than Date of Joining,Malšinančių data turi būti didesnis nei įstoti data
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238,Leaves per Year,Lapai per metus
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +128,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Eilutės {0}: Prašome patikrinti &quot;yra iš anksto&quot; prieš paskyra {1}, jei tai yra išankstinis įrašas."
apps/erpnext/erpnext/stock/utils.py +216,Warehouse {0} does not belong to company {1},Sandėlių {0} nepriklauso bendrovei {1}
DocType: Email Digest,Profit & Loss,Pelnas ir nuostoliai
apps/erpnext/erpnext/utilities/user_progress.py +144,Litre,litrų
DocType: Task,Total Costing Amount (via Time Sheet),Iš viso Sąnaudų suma (per Time lapas)
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +69,Please setup Students under Student Groups,Nustatykite studentus pagal studentų grupes
DocType: Item Website Specification,Item Website Specification,Prekė svetainė Specifikacija
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +509,Leave Blocked,Palikite Užblokuoti
apps/erpnext/erpnext/stock/doctype/item/item.py +709,Item {0} has reached its end of life on {1},Prekės {0} galiojimas pasibaigė {1}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +99,Bank Entries,Banko įrašai
DocType: Crop,Annual,metinis
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Akcijų Susitaikymas punktas
DocType: Stock Entry,Sales Invoice No,Pardavimų sąskaita faktūra nėra
DocType: Material Request Item,Min Order Qty,Min Užsakomas kiekis
DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Studentų grupė kūrimo įrankis kursai
DocType: Lead,Do Not Contact,Nėra jokio tikslo susisiekti
apps/erpnext/erpnext/utilities/user_progress.py +207,People who teach at your organisation,"Žmonės, kurie mokyti savo organizaciją"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135,Software Developer,Programinės įrangos kūrėjas
DocType: Item,Minimum Order Qty,Mažiausias užsakymo Kiekis
DocType: Pricing Rule,Supplier Type,tiekėjas tipas
DocType: Course Scheduling Tool,Course Start Date,Žinoma pradžios data
,Student Batch-Wise Attendance,Studentų Serija-Išminčius Lankomumas
DocType: POS Profile,Allow user to edit Rate,Leisti vartotojui redaguoti Balsuok
DocType: Item,Publish in Hub,Skelbia Hub
DocType: Student Admission,Student Admission,Studentų Priėmimas
,Terretory,Terretory
apps/erpnext/erpnext/stock/doctype/item/item.py +729,Item {0} is cancelled,Prekė {0} atšaukiamas
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +952,Material Request,medžiaga Prašymas
DocType: Bank Reconciliation,Update Clearance Date,Atnaujinti Sąskaitų data
DocType: Item,Purchase Details,pirkimo informacija
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +387,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Prekė {0} nerastas &quot;In žaliavos&quot; stalo Užsakymo {1}
DocType: Salary Slip,Total Principal Amount,Visa pagrindinė suma
DocType: Student Guardian,Relation,santykis
DocType: Student Guardian,Mother,Motina
DocType: Restaurant Reservation,Reservation End Time,Rezervacijos pabaiga
DocType: Crop,Biennial,Bienalė
apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Patvirtinti užsakymus iš klientų.
DocType: Purchase Receipt Item,Rejected Quantity,atmesta Kiekis
apps/erpnext/erpnext/education/doctype/fees/fees.py +80,Payment request {0} created,Mokesčio užklausa {0} sukurta
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Open Orders,Atvirieji užsakymai
apps/erpnext/erpnext/healthcare/setup.py +255,Low Sensitivity,Žemas jautrumas
DocType: Notification Control,Notification Control,pranešimas Valdymo
apps/erpnext/erpnext/templates/emails/training_event.html +17,Please confirm once you have completed your training,"Patvirtinkite, kai baigsite savo mokymą"
DocType: Lead,Suggestions,Pasiūlymai
DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Rinkinio prekė Grupė išmintingas biudžetai šioje teritorijoje. Taip pat galite įtraukti sezoniškumą nustatant platinimas.
DocType: Payment Term,Payment Term Name,Mokėjimo terminas Vardas
DocType: Healthcare Settings,Create documents for sample collection,Sukurkite dokumentus pavyzdžių rinkimui
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +274,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Mokėjimo prieš {0} {1} negali būti didesnis nei nesumokėtos sumos {2}
DocType: Supplier,Address HTML,adresas HTML
DocType: Lead,Mobile No.,Mobilus Ne
DocType: Maintenance Schedule,Generate Schedule,Sukurti Tvarkaraštis
DocType: Purchase Invoice Item,Expense Head,Kompensuojamos vadovas
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +163,Please select Charge Type first,Prašome pasirinkti mokesčių rūšis pirmą kartą
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.. ","Čia galite apibrėžti visas užduotis, kurių reikia atlikti šiam pasėliui. Dienos laukas naudojamas paminėti tą dieną, kurią reikia atlikti užduotį, 1 yra 1 diena ir kt."
DocType: Student Group Student,Student Group Student,Studentų grupė studentė
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,paskutinis
DocType: Asset Maintenance Task,2 Yearly,2 metai
DocType: Education Settings,Education Settings,Švietimo nustatymai
DocType: Vehicle Service,Inspection,Apžiūra
DocType: Supplier Scorecard Scoring Standing,Max Grade,Maksimalus įvertinimas
DocType: Email Digest,New Quotations,Nauja citatos
DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,Parašyta darbo užmokestį į darbuotojo remiantis pageidaujamą paštu pasirinkto darbuotojo
DocType: Employee,The first Leave Approver in the list will be set as the default Leave Approver,Pirmasis atostogos Tvirtintojas sąraše bus nustatytas kaip numatytasis Palikite jį patvirtinusio
DocType: Tax Rule,Shipping County,Pristatymas apskritis
apps/erpnext/erpnext/config/desktop.py +167,Learn,Mokytis
DocType: Asset,Next Depreciation Date,Kitas Nusidėvėjimas data
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Veiklos sąnaudos vienam darbuotojui
DocType: Accounts Settings,Settings for Accounts,Nustatymai sąskaitų
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +673,Supplier Invoice No exists in Purchase Invoice {0},Tiekėjas sąskaitoje Nr egzistuoja pirkimo sąskaitoje faktūroje {0}
apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Valdyti pardavimo asmuo medį.
DocType: Job Applicant,Cover Letter,lydraštis
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Neįvykdyti čekiai ir užstatai ir išvalyti
DocType: Item,Synced With Hub,Sinchronizuojami su Hub
DocType: Driver,Fleet Manager,laivyno direktorius
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542,Row #{0}: {1} can not be negative for item {2},Eilutė # {0}: {1} negali būti neigiamas už prekę {2}
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59,Wrong Password,Neteisingas slaptažodis
DocType: Item,Variant Of,variantas
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +387,Completed Qty can not be greater than 'Qty to Manufacture',Užbaigtas Kiekis negali būti didesnis nei &quot;Kiekis iki Gamyba&quot;
DocType: Period Closing Voucher,Closing Account Head,Uždarymo sąskaita vadovas
DocType: Employee,External Work History,Išorinis darbo istoriją
DocType: Physician,Time per Appointment,Paskyrimo laikas
apps/erpnext/erpnext/projects/doctype/task/task.py +110,Circular Reference Error,Ciklinę nuorodą Klaida
DocType: Appointment Type,Is Inpatient,Yra stacionarus
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Guardian1 Vardas
DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,"Žodžiais (eksportas) bus matomas, kai jūs išgelbėti važtaraštyje."
DocType: Cheque Print Template,Distance from left edge,Atstumas nuo kairiojo krašto
apps/erpnext/erpnext/utilities/bot.py +29,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} vienetai [{1}] (# forma / vnt / {1}) rasta [{2}] (# forma / sandėliavimo / {2})
DocType: Lead,Industry,Industrija
DocType: Employee,Job Profile,darbo profilis
DocType: BOM Item,Rate & Amount,Įvertinti ir sumą
apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6,This is based on transactions against this Company. See timeline below for details,Tai grindžiama sandoriais prieš šią bendrovę. Žiūrėkite žemiau pateiktą laiko juostą
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Praneškite elektroniniu paštu steigti automatinio Medžiaga Užsisakyti
apps/erpnext/erpnext/healthcare/setup.py +259,Resistant,Atsparus
apps/erpnext/erpnext/config/desktop.py +309,Consultationt,Konsultavimas
DocType: Journal Entry,Multi Currency,Daugiafunkciniai Valiuta
DocType: Opening Invoice Creation Tool,Invoice Type,Sąskaitos faktūros tipas
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +933,Delivery Note,Važtaraštis
DocType: Consultation,Encounter Impression,Susiduria su įspūdžiais
apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,Įsteigti Mokesčiai
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134,Cost of Sold Asset,Kaina Parduota turto
DocType: Volunteer,Morning,Rytas
apps/erpnext/erpnext/accounts/utils.py +350,Payment Entry has been modified after you pulled it. Please pull it again.,"Mokėjimo Įrašas buvo pakeistas po to, kai ištraukė ją. Prašome traukti jį dar kartą."
DocType: Program Enrollment Tool,New Student Batch,Naujoji studentų partija
apps/erpnext/erpnext/stock/doctype/item/item.py +464,{0} entered twice in Item Tax,{0} įvestas du kartus Prekės mokesčio
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,Summary for this week and pending activities,Santrauka šią savaitę ir laukiant veikla
DocType: Student Applicant,Admitted,pripažino
DocType: Workstation,Rent Cost,nuomos kaina
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81,Amount After Depreciation,Suma po nusidėvėjimo
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,Artimiausi Kalendoriaus įvykiai
apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1,Variant Attributes,Varianto atributai
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85,Please select month and year,Prašome pasirinkti mėnesį ir metus
DocType: Employee,Company Email,Įmonės paštas
DocType: GL Entry,Debit Amount in Account Currency,Debeto Suma sąskaitos valiuta
DocType: Supplier Scorecard,Scoring Standings,Taškų skaičiavimas
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,Užsakyti Vertė
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,Užsakyti Vertė
apps/erpnext/erpnext/config/accounts.py +27,Bank/Cash transactions against party or for internal transfer,Bankas / Grynųjų pinigų operacijos nuo šalies arba dėl vidinio pervedimo
DocType: Shipping Rule,Valid for Countries,Galioja šalių
apps/erpnext/erpnext/stock/doctype/item/item.js +55,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,Šis punktas yra šablonų ir negali būti naudojamas sandoriams. Elemento atributai bus nukopijuoti į variantai nebent &quot;Ne Kopijuoti&quot; yra nustatytas
DocType: Grant Application,Grant Application,Paraiškos dotacija
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Viso Užsakyti Laikomas
apps/erpnext/erpnext/config/hr.py +243,"Employee designation (e.g. CEO, Director etc.).","Darbuotojų žymėjimas (pvz Vadovas, direktorius ir tt)."
DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,"Norma, pagal kurią Klientas valiuta konvertuojama į kliento bazine valiuta"
DocType: Course Scheduling Tool,Course Scheduling Tool,Žinoma planavimas įrankių
apps/erpnext/erpnext/controllers/accounts_controller.py +622,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Eilutės # {0}: Pirkimo sąskaita faktūra negali būti pareikštas esamo turto {1}
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +255,[Urgent] Error while creating recurring %s for %s,[Skubi] Klaida kuriant pasikartojančius% s% s
DocType: Land Unit,LInked Analysis,Įtraukta analizė
DocType: Item Tax,Tax Rate,Mokesčio tarifas
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59,{0} already allocated for Employee {1} for period {2} to {3},{0} jau skirta darbuotojo {1} laikotarpiui {2} į {3}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +919,Select Item,Pasirinkite punktas
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +141,Purchase Invoice {0} is already submitted,Pirkimo sąskaita faktūra {0} jau pateiktas
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +91,Row # {0}: Batch No must be same as {1} {2},"Eilutės # {0}: Serijos Nr turi būti toks pat, kaip {1} {2}"
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,Konvertuoti į ne grupės
DocType: C-Form Invoice Detail,Invoice Date,Sąskaitos data
DocType: GL Entry,Debit Amount,debeto suma
apps/erpnext/erpnext/accounts/party.py +251,There can only be 1 Account per Company in {0} {1},Gali būti tik 1 sąskaita už Bendrovės {0} {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +426,Please see attachment,Žiūrėkite priedą
DocType: Purchase Order,% Received,% vartojo
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Sukurti studentų grupių
DocType: Volunteer,Weekends,Savaitgaliai
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Credit Note Amount,Kredito Pastaba suma
DocType: Setup Progress Action,Action Document,Veiksmų dokumentas
DocType: Chapter Member,Website URL,Svetainės URL
,Finished Goods,gatavų prekių
DocType: Delivery Note,Instructions,instrukcijos
DocType: Quality Inspection,Inspected By,tikrina
DocType: Asset Maintenance Log,Maintenance Type,priežiūra tipas
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45,{0} - {1} is not enrolled in the Course {2},{0} - {1} nėra įtraukti į objekto {2}
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},Serijos Nr {0} nepriklauso važtaraštyje {1}
apps/erpnext/erpnext/templates/pages/demo.html +47,ERPNext Demo,ERPNext demo
apps/erpnext/erpnext/public/js/utils/item_selector.js +20,Add Items,Pridėti prekę
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Prekė kokybės inspekcija Parametras
DocType: Leave Application,Leave Approver Name,Palikite jį patvirtinusio pavadinimas
DocType: Depreciation Schedule,Schedule Date,Tvarkaraštis data
apps/erpnext/erpnext/config/hr.py +116,"Earnings, Deductions and other Salary components","Darbo užmokestis, atskaitymai ir kito atlyginimo dalys"
DocType: Packed Item,Packed Item,supakuotas punktas
apps/erpnext/erpnext/config/buying.py +65,Default settings for buying transactions.,Numatytieji nustatymai pirkti sandorius.
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},Veiklos sąnaudos egzistuoja darbuotojo {0} prieš Veiklos rūšis - {1}
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15,Mandatory field - Get Students From,Privalomas laukas - Gauk Studentai iš
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15,Mandatory field - Get Students From,Privalomas laukas - Gauk Studentai iš
DocType: Program Enrollment,Enrolled courses,studijuojantys kursai
DocType: Program Enrollment,Enrolled courses,studijuojantys kursai
DocType: Currency Exchange,Currency Exchange,Valiutos keitykla
DocType: Opening Invoice Creation Tool Item,Item Name,Daikto pavadinimas
DocType: Authorization Rule,Approving User  (above authorized value),Patvirtinimo vartotoją (virš įgalioto vertės)
DocType: Email Digest,Credit Balance,Kredito balansas
DocType: Employee,Widowed,likusi našle
DocType: Request for Quotation,Request for Quotation,Užklausimas
DocType: Healthcare Settings,Require Lab Test Approval,Reikalauti gero bandymo patvirtinimo
DocType: Salary Slip Timesheet,Working Hours,Darbo valandos
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +10,Total Outstanding,Viso neįvykdyti
DocType: Naming Series,Change the starting / current sequence number of an existing series.,Pakeisti pradinį / trumpalaikiai eilės numerį esamo serijos.
DocType: Dosage Strength,Strength,Jėga
apps/erpnext/erpnext/accounts/page/pos/pos.js +1524,Create a new Customer,Sukurti naują klientų
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.","Jei ir toliau vyrauja daug kainodaros taisyklės, vartotojai, prašoma, kad prioritetas rankiniu būdu išspręsti konfliktą."
apps/erpnext/erpnext/utilities/activation.py +90,Create Purchase Orders,Sukurti Pirkimų užsakymus
,Purchase Register,pirkimo Registruotis
DocType: Scheduling Tool,Rechedule,Rechedule
DocType: Landed Cost Item,Applicable Charges,Taikomi Mokesčiai
DocType: Workstation,Consumable Cost,vartojimo kaina
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +220,{0} ({1}) must have role 'Leave Approver',{0} ({1}) turi vaidmenį &quot;Atostogos Tvirtintojas&quot;
DocType: Purchase Receipt,Vehicle Date,Automobilio data
DocType: Student Log,Medical,medicinos
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +177,Reason for losing,"Priežastis, dėl kurios praranda"
apps/erpnext/erpnext/accounts/doctype/account/account.js +52,Update Account Number,Atnaujinti sąskaitos numerį
apps/erpnext/erpnext/crm/doctype/lead/lead.py +42,Lead Owner cannot be same as the Lead,"Švinas savininkas gali būti toks pat, kaip pirmaujančios"
apps/erpnext/erpnext/accounts/utils.py +356,Allocated amount can not greater than unadjusted amount,Paskirti suma gali ne didesnis nei originalios suma
DocType: Announcement,Receiver,imtuvas
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,Workstation is closed on the following dates as per Holiday List: {0},"Kompiuterizuotos darbo vietos yra uždarytas šių datų, kaip už Atostogų sąrašas: {0}"
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32,Opportunities,galimybės
DocType: Lab Test Template,Single,vienas
DocType: Salary Slip,Total Loan Repayment,Viso paskolų grąžinimas
DocType: Account,Cost of Goods Sold,Parduotų prekių kaina
DocType: Subscription,Yearly,kasmet
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230,Please enter Cost Center,Prašome įvesti sąnaudų centro
DocType: Drug Prescription,Dosage,Dozavimas
DocType: Journal Entry Account,Sales Order,Pardavimo užsakymas
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69,Avg. Selling Rate,Vid. pardavimo kaina
DocType: Assessment Plan,Examiner Name,Eksperto vardas
DocType: Lab Test Template,No Result,Nėra rezultatas
DocType: Purchase Invoice Item,Quantity and Rate,Kiekis ir Balsuok
DocType: Delivery Note,% Installed,% Įdiegta
apps/erpnext/erpnext/utilities/user_progress.py +227,Classrooms/ Laboratories etc where lectures can be scheduled.,"Kabinetai / Laboratorijos tt, kai paskaitos gali būti planuojama."
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Please enter company name first,Prašome įvesti įmonės pavadinimą pirmoji
DocType: Purchase Invoice,Supplier Name,tiekėjas Vardas
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25,Read the ERPNext Manual,Skaityti ERPNext vadovas
DocType: Account,Is Group,yra grupė
DocType: Email Digest,Pending Purchase Orders,Kol Pirkimų užsakymus
DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Automatiškai Eilės Nr remiantis FIFO
DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Patikrinkite Tiekėjas sąskaitos faktūros numeris Unikalumas
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34,Primary Address Details,Pagrindinio adreso duomenys
DocType: Vehicle Service,Oil Change,Tepalų keitimas
DocType: Asset Maintenance Log,Asset Maintenance Log,Turto priežiūros žurnalas
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.',"&quot;Norėdami Byla Nr &#39; negali būti mažesnė, nei &quot;Nuo byla Nr &#39;"
DocType: Chapter,Non Profit,nepelno
DocType: Production Order,Not Started,Nepradėjau
DocType: Lead,Channel Partner,kanalo Partneriai
DocType: Account,Old Parent,Senas Tėvų
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19,Mandatory field - Academic Year,Privalomas laukas - akademiniai metai
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19,Mandatory field - Academic Year,Privalomas laukas - akademiniai metai
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,{0} {1} is not associated with {2} {3},{0} {1} nėra susietas su {2} {3}
DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,"Tinkinti įvadinį tekstą, kad eina kaip tos paštu dalį. Kiekvienas sandoris turi atskirą įžanginį tekstą."
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +182,Please set default payable account for the company {0},Prašome nustatyti numatytąją mokėtiną sąskaitos už bendrovės {0}
DocType: Setup Progress Action,Min Doc Count,Min Doc Count
apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Global nustatymai visus gamybos procesus.
DocType: Accounts Settings,Accounts Frozen Upto,Sąskaitos Šaldyti upto
DocType: SMS Log,Sent On,išsiųstas
apps/erpnext/erpnext/stock/doctype/item/item.py +671,Attribute {0} selected multiple times in Attributes Table,Įgūdis {0} pasirinktas kelis kartus požymiai lentelėje
DocType: HR Settings,Employee record is created using selected field. ,Darbuotojų įrašas sukurtas naudojant pasirinktą lauką.
DocType: Sales Order,Not Applicable,Netaikoma
apps/erpnext/erpnext/config/hr.py +70,Holiday master.,Atostogų meistras.
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +77,Opening Invoice Item,Atidarymo sąskaitos faktūros punktas
DocType: Request for Quotation Item,Required Date,Reikalinga data
DocType: Delivery Note,Billing Address,atsiskaitymo Adresas
DocType: BOM,Costing,Sąnaudų
DocType: Tax Rule,Billing County,atsiskaitymo apskritis
DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Jei pažymėta, mokesčių suma bus laikoma jau įtrauktas Print Rate / Spausdinti Suma"
DocType: Request for Quotation,Message for Supplier,Pranešimo tiekėjas
DocType: Driver,DRIVER-.#####,DRIVER -. #####
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Qty,viso Kiekis
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 E-mail ID
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 E-mail ID
DocType: Item,Show in Website (Variant),Rodyti svetainė (variantas)
DocType: Employee,Health Concerns,sveikatos problemas
DocType: Payroll Entry,Select Payroll Period,Pasirinkite Darbo užmokesčio laikotarpis
DocType: Purchase Invoice,Unpaid,neapmokamas
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49,Reserved for sale,Skirta pardavimui
apps/erpnext/erpnext/hr/doctype/employee/employee.py +24,Please setup Employee Naming System in Human Resource &gt; HR Settings,Prašome nustatyti darbuotojų pavadinimo sistemą žmogiškųjų išteklių&gt; HR nustatymai
DocType: Packing Slip,From Package No.,Nuo paketas Nr
DocType: Item Attribute,To Range,Norėdami Diapazonas
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29,Securities and Deposits,Vertybiniai popieriai ir užstatai
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Nepavyksta pakeisti vertinimo metodą, nes yra sandoriai prieš kai daiktų kuri neturi tai savo vertinimo metodas"
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82,Total leaves allocated is mandatory,skiriamos viso lapai yra privalomi
DocType: Patient,AB Positive,AB teigiamas
DocType: Job Opening,Description of a Job Opening,Aprašymas apie Darbo skelbimai
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110,Pending activities for today,Kol veikla šiandien
apps/erpnext/erpnext/config/hr.py +24,Attendance record.,Lankomumas įrašas.
DocType: Salary Structure,Salary Component for timesheet based payroll.,Pajamos komponentas žiniaraštis pagrįstą darbo užmokesčio.
DocType: Sales Order Item,Used for Production Plan,Naudojamas gamybos planas
DocType: Employee Loan,Total Payment,bendras Apmokėjimas
DocType: Manufacturing Settings,Time Between Operations (in mins),Laikas tarp operacijų (minutėmis)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +129,{0} {1} is cancelled so the action cannot be completed,{0} {1} yra atšaukta ir todėl veiksmai negali būti užbaigtas
DocType: Customer,Buyer of Goods and Services.,Pirkėjas prekes ir paslaugas.
DocType: Journal Entry,Accounts Payable,MOKĖTINOS SUMOS
DocType: Patient,Allergies,Alergijos
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +30,The selected BOMs are not for the same item,Pasirinktos BOMs yra ne to paties objekto
DocType: Supplier Scorecard Standing,Notify Other,Pranešti apie kitą
DocType: Vital Signs,Blood Pressure (systolic),Kraujo spaudimas (sistolinis)
DocType: Pricing Rule,Valid Upto,galioja upto
DocType: Training Event,Workshop,dirbtuvė
DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Įspėti pirkimo užsakymus
apps/erpnext/erpnext/utilities/user_progress.py +64,List a few of your customers. They could be organizations or individuals.,Sąrašas keletą savo klientams. Jie gali būti organizacijos ar asmenys.
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +23,Enough Parts to Build,Pakankamai Dalys sukurti
DocType: POS Profile User,POS Profile User,POS vartotojo profilis
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128,Direct Income,tiesioginių pajamų
DocType: Patient Appointment,Date TIme,Data TIme
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +41,"Can not filter based on Account, if grouped by Account","Negali filtruoti pagal sąskaitą, jei sugrupuoti pagal sąskaitą"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130,Administrative Officer,administracijos pareigūnas
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39,Setting up company and taxes,Įmonės steigimas ir mokesčiai
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,Prašome pasirinkti kursai
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,Prašome pasirinkti kursai
DocType: Codification Table,Codification Table,Kodifikavimo lentelė
DocType: Timesheet Detail,Hrs,h
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +350,Please select Company,Prašome pasirinkti kompaniją
DocType: Stock Entry Detail,Difference Account,skirtumas paskyra
DocType: Purchase Invoice,Supplier GSTIN,tiekėjas GSTIN
apps/erpnext/erpnext/projects/doctype/task/task.py +47,Cannot close task as its dependant task {0} is not closed.,"Ar nėra artimas užduotis, nes jos priklauso nuo užduoties {0} nėra uždarytas."
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +435,Please enter Warehouse for which Material Request will be raised,"Prašome įvesti sandėlis, kuris bus iškeltas Medžiaga Prašymas"
DocType: Production Order,Additional Operating Cost,Papildoma eksploatavimo išlaidos
DocType: Lab Test Template,Lab Routine,&quot;Lab Routine&quot;
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20,Cosmetics,kosmetika
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18,Please select Completion Date for Completed Asset Maintenance Log,Prašome pasirinkti baigtinio turto priežiūros žurnalo užbaigimo datą
apps/erpnext/erpnext/stock/doctype/item/item.py +526,"To merge, following properties must be same for both items","Sujungti, šie savybės turi būti tokios pačios tiek daiktų"
DocType: Shipping Rule,Net Weight,Grynas svoris
DocType: Employee,Emergency Phone,avarinis telefonas
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,nupirkti
,Serial No Warranty Expiry,Serijos Nr Garantija galiojimo
DocType: Sales Invoice,Offline POS Name,Atsijungęs amp Vardas
apps/erpnext/erpnext/utilities/user_progress.py +177,Student Application,Studento paraiška
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Prašome apibrėžti kokybės už slenksčio 0%
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Prašome apibrėžti kokybės už slenksčio 0%
DocType: Sales Order,To Deliver,Pristatyti
DocType: Purchase Invoice Item,Item,Prekė
apps/erpnext/erpnext/healthcare/setup.py +256,High Sensitivity,Didelis jautrumas
apps/erpnext/erpnext/config/non_profit.py +48,Volunteer Type information.,Savanorio tipo informacija.
apps/erpnext/erpnext/accounts/page/pos/pos.js +2513,Serial no item cannot be a fraction,Serijos Nr punktas negali būti frakcija
DocType: Journal Entry,Difference (Dr - Cr),Skirtumas (dr - Cr)
DocType: Account,Profit and Loss,Pelnas ir nuostoliai
DocType: Patient,Risk Factors,Rizikos veiksniai
DocType: Patient,Occupational Hazards and Environmental Factors,Profesiniai pavojai ir aplinkos veiksniai
DocType: Vital Signs,Respiratory rate,Kvėpavimo dažnis
apps/erpnext/erpnext/config/stock.py +330,Managing Subcontracting,valdymas Subranga
DocType: Vital Signs,Body Temperature,Kūno temperatūra
DocType: Project,Project will be accessible on the website to these users,Projektas bus prieinama tinklalapyje šių vartotojų
DocType: Detected Disease,Disease,Liga
apps/erpnext/erpnext/config/projects.py +24,Define Project type.,Nurodykite projekto tipą.
DocType: Supplier Scorecard,Weighting Function,Svorio funkcija
DocType: Physician,OP Consulting Charge,&quot;OP Consulting&quot; mokestis
apps/erpnext/erpnext/utilities/user_progress.py +25,Setup your ,Nustatykite savo
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,"Norma, pagal kurią Kainoraštis valiuta konvertuojama į įmonės bazine valiuta"
apps/erpnext/erpnext/setup/doctype/company/company.py +69,Account {0} does not belong to company: {1},Sąskaita {0} nepriklauso įmonės: {1}
apps/erpnext/erpnext/setup/doctype/company/company.py +51,Abbreviation already used for another company,Santrumpa jau naudojamas kitos bendrovės
DocType: Selling Settings,Default Customer Group,Pagal nutylėjimą klientų grupei
DocType: Asset Repair,ARLOG-,ARLOG-
DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction",Jei išjungti &quot;suapvalinti sumą&quot; laukas nebus matomas bet koks sandoris
DocType: BOM,Operating Cost,Operacinė Kaina
DocType: Crop,Produced Items,Pagaminti daiktai
DocType: Sales Order Item,Gross Profit,Bendrasis pelnas
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,"Prieaugis negali būti 0,"
DocType: Production Planning Tool,Material Requirement,medžiagų poreikis
DocType: Company,Delete Company Transactions,Ištrinti bendrovės verslo sandoriai
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +351,Reference No and Reference Date is mandatory for Bank transaction,Nuorodos Nr ir nuoroda data yra privalomas banko sandorio
DocType: Purchase Receipt,Add / Edit Taxes and Charges,Įdėti / Redaguoti mokesčių ir rinkliavų
DocType: Payment Entry Reference,Supplier Invoice No,Tiekėjas sąskaitoje Nr
DocType: Territory,For reference,prašymą priimti prejudicinį sprendimą
DocType: Healthcare Settings,Appointment Confirmation,Paskyrimo patvirtinimas
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"Cannot delete Serial No {0}, as it is used in stock transactions","Negalite trinti Serijos Nr {0}, kaip ji yra naudojama akcijų sandorių"
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +253,Closing (Cr),Uždarymo (CR)
apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1,Hello,Sveiki
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +110,Move Item,Perkelti punktas
DocType: Serial No,Warranty Period (Days),Garantinis laikotarpis (dienomis)
DocType: Installation Note Item,Installation Note Item,Įrengimas Pastaba Prekė
DocType: Production Plan Item,Pending Qty,Kol Kiekis
DocType: Budget,Ignore,ignoruoti
apps/erpnext/erpnext/accounts/party.py +384,{0} {1} is not active,{0} {1} is not active
apps/erpnext/erpnext/config/accounts.py +272,Setup cheque dimensions for printing,Sąranka patikrinti matmenys spausdinti
DocType: Salary Slip,Salary Slip Timesheet,Pajamos Kuponas Lapą
apps/erpnext/erpnext/controllers/buying_controller.py +160,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Tiekėjas tiekiantis sandėlis privalomas SUBRANGOVAMS pirkimo kvito
DocType: Pricing Rule,Valid From,Galioja nuo
DocType: Sales Invoice,Total Commission,Iš viso Komisija
DocType: Pricing Rule,Sales Partner,Partneriai pardavimo
apps/erpnext/erpnext/config/buying.py +150,All Supplier scorecards.,Visi tiekėjų rezultatų kortelės.
DocType: Buying Settings,Purchase Receipt Required,Pirkimo kvito Reikalinga
apps/erpnext/erpnext/stock/doctype/item/item.py +144,Valuation Rate is mandatory if Opening Stock entered,"Vertinimo rodiklis yra privalomas, jei atidarymas sandėlyje įvesta"
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +142,No records found in the Invoice table,rasti sąskaitos faktūros lentelės Nėra įrašų
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +17,Please select Company and Party Type first,Prašome pasirinkti bendrovė ir šalies tipo pirmas
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31,"Already set default in pos profile {0} for user {1}, kindly disabled default","Jau nustatytas numatytasis naudotojo {1} pos profilyje {0}, maloniai išjungtas numatytasis"
apps/erpnext/erpnext/config/accounts.py +293,Financial / accounting year.,Finansų / apskaitos metus.
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,sukauptos vertybės
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"Sorry, Serial Nos cannot be merged","Atsiprašome, Eilės Nr negali būti sujungtos"
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72,Territory is Required in POS Profile,Teritorija reikalinga POS profilyje
DocType: Supplier,Prevent RFQs,Užkirsti kelią RFQ
apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Padaryti pardavimo užsakymų
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168,Salary Slip submitted for period from {0} to {1},Atlyginimo užstatas pateiktas laikotarpiui nuo {0} iki {1}
DocType: Project Task,Project Task,Projektų Užduotis
,Lead Id,Švinas ID
DocType: C-Form Invoice Detail,Grand Total,Bendra suma
DocType: Assessment Plan,Course,kursas
DocType: Timesheet,Payslip,algalapį
apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,krepšelis
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Finansiniai metai pradžios data turėtų būti ne didesnis nei finansinių metų pabaigos data
DocType: Issue,Resolution,rezoliucija
DocType: C-Form,IV,IV
apps/erpnext/erpnext/templates/pages/order.html +76,Delivered: {0},Paskelbta: {0}
DocType: Expense Claim,Payable Account,mokėtinos sąskaitos
DocType: Payment Entry,Type of Payment,Mokėjimo rūšis
DocType: Sales Order,Billing and Delivery Status,Atsiskaitymo ir pristatymo statusas
DocType: Job Applicant,Resume Attachment,Gyvenimo Priedas
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Pakartokite Klientai
DocType: Leave Control Panel,Allocate,paskirstyti
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108,Create Variant,Sukurkite variantą
DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Sąskaitų faktūrų kūrimo įrankio atidarymas
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +851,Sales Return,pardavimų Grįžti
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96,Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,Pastaba: Iš viso skiriami lapai {0} turi būti ne mažesnis nei jau patvirtintų lapų {1} laikotarpiui
,Total Stock Summary,Viso sandėlyje santrauka
DocType: Announcement,Posted By,Paskelbtas
DocType: Item,Delivered by Supplier (Drop Ship),Paskelbta tiekėjo (Drop Ship)
DocType: Healthcare Settings,Confirmation Message,Patvirtinimo pranešimas
apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,Duomenų bazė potencialiems klientams.
DocType: Authorization Rule,Customer or Item,Klientas ar punktas
apps/erpnext/erpnext/config/selling.py +28,Customer database.,Klientų duomenų bazė.
DocType: Quotation,Quotation To,citatos
DocType: Lead,Middle Income,vidutines pajamas
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +225,Opening (Cr),Anga (Cr)
apps/erpnext/erpnext/stock/doctype/item/item.py +835,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.,"Numatytasis Matavimo vienetas už prekę {0} negali būti pakeistas tiesiogiai, nes jūs jau padarė tam tikrą sandorį (-ius) su kitu UOM. Jums reikės sukurti naują elementą naudoti kitą numatytąjį UOM."
apps/erpnext/erpnext/accounts/utils.py +354,Allocated amount can not be negative,Paskirti suma negali būti neigiama
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Prašome nurodyti Bendrovei
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Prašome nurodyti Bendrovei
DocType: Purchase Order Item,Billed Amt,Apmokestinti Amt
DocType: Training Result Employee,Training Result Employee,Mokymai Rezultatas Darbuotojų
DocType: Warehouse,A logical Warehouse against which stock entries are made.,Logiškas Sandėlių nuo kurių akcijų įrašai būtų daromi.
DocType: Repayment Schedule,Principal Amount,pagrindinę sumą
DocType: Employee Loan Application,Total Payable Interest,Viso mokėtinos palūkanos
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +60,Total Outstanding: {0},Iš viso neįvykdyti: {0}
DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Pardavimų sąskaita faktūra Lapą
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +116,Reference No & Reference Date is required for {0},Nuorodos Nr &amp; nuoroda data reikalingas {0}
DocType: Payroll Entry,Select Payment Account to make Bank Entry,"Pasirinkite mokėjimo sąskaitos, kad bankų įėjimo"
apps/erpnext/erpnext/utilities/activation.py +136,"Create Employee records to manage leaves, expense claims and payroll","Sukurti darbuotojams įrašus valdyti lapai, išlaidų paraiškos ir darbo užmokesčio"
DocType: Restaurant Reservation,Restaurant Reservation,Restorano rezervavimas
DocType: Land Unit,Land Unit Name,Žemės vieneto pavadinimas
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190,Proposal Writing,Pasiūlymas rašymas
DocType: Payment Entry Deduction,Payment Entry Deduction,Mokėjimo Įėjimo išskaičiavimas
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14,Wrapping up,Įpakavimas
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35,Notify Customers via Email,Pranešti klientams el. Paštu
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,Kitas pardavimų asmuo {0} egzistuoja su tuo pačiu Darbuotojo ID
DocType: Employee Advance,Claimed Amount,Reikalaujama suma
DocType: Production Planning Tool,"If checked, raw materials for items that are sub-contracted will be included in the Material Requests","Jei pažymėta, žaliavas elementus, kurie yra subrangovams bus įtrauktas į Materialiųjų Prašymai"
apps/erpnext/erpnext/config/healthcare.py +62,Masters,Kandidatas
DocType: Assessment Plan,Maximum Assessment Score,Maksimalus vertinimo balas
apps/erpnext/erpnext/config/accounts.py +138,Update Bank Transaction Dates,Atnaujinti banko sandorio dieną
apps/erpnext/erpnext/config/projects.py +36,Time Tracking,laikas stebėjimas
DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,Dublikatą TRANSPORTER
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49,Row {0}# Paid Amount cannot be greater than requested advance amount,Eilutė {0} # Mokama suma negali būti didesnė už prašomą avansą
DocType: Fiscal Year Company,Fiscal Year Company,Finansiniai metai Įmonės
DocType: Packing Slip Item,DN Detail,DN detalės
DocType: Training Event,Conference,konferencija
DocType: Timesheet,Billed,įvardintas
DocType: Batch,Batch Description,Serija Aprašymas
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Studentų grupės kūrimas
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Studentų grupės kūrimas
apps/erpnext/erpnext/accounts/utils.py +727,"Payment Gateway Account not created, please create one manually.","Mokėjimo šliuzai paskyra nebuvo sukurta, prašome sukurti rankiniu būdu."
DocType: Supplier Scorecard,Per Year,Per metus
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,Negalima dalyvauti šioje programoje pagal DOB
DocType: Sales Invoice,Sales Taxes and Charges,Pardavimų Mokesčiai ir rinkliavos
DocType: Employee,Organization Profile,organizacijos profilį
DocType: Vital Signs,Height (In Meter),Aukštis (matuoklyje)
DocType: Student,Sibling Details,Giminystės detalės
DocType: Vehicle Service,Vehicle Service,Autoservisų
apps/erpnext/erpnext/config/setup.py +101,Automatically triggers the feedback request based on conditions.,Automatiškai įjungia atsiliepimai prašymas grindžiamas sąlygomis.
DocType: Employee,Reason for Resignation,"Priežastis, dėl atsistatydinimo"
apps/erpnext/erpnext/config/hr.py +152,Template for performance appraisals.,Šablonas našumo vertinimus.
DocType: Sales Invoice,Credit Note Issued,Kredito Pastaba Išduotas
DocType: Project Task,Weight,svoris
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Sąskaita / leidinys Įėjimo detalės
apps/erpnext/erpnext/accounts/utils.py +83,{0} '{1}' not in Fiscal Year {2},{0} &quot;{1}&quot; ne fiskaliniais metais {2}
DocType: Buying Settings,Settings for Buying Module,Nustatymai Ieško modulis
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21,Asset {0} does not belong to company {1},Turto {0} nepriklauso bendrovei {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70,Please enter Purchase Receipt first,Prašome įvesti pirkimo kvito pirmasis
DocType: Buying Settings,Supplier Naming By,Tiekėjas įvardijimas Iki
DocType: Activity Type,Default Costing Rate,Numatytasis Sąnaudų norma
DocType: Maintenance Schedule,Maintenance Schedule,Priežiūros planas
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Tada Kainodaros taisyklės yra išfiltruotas remiantis Klientui, klientų grupės, teritorijoje, tiekėjas, Tiekėjas tipas, kampanijos partneris pardavimo ir tt"
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24,Net Change in Inventory,Grynasis pokytis Inventorius
apps/erpnext/erpnext/config/hr.py +162,Employee Loan Management,Darbuotojų Paskolos valdymas
DocType: Employee,Passport Number,Paso numeris
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Ryšys su Guardian2
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124,Manager,vadybininkas
DocType: Payment Entry,Payment From / To,Mokėjimo Nuo / Iki
apps/erpnext/erpnext/selling/doctype/customer/customer.py +156,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Nauja kredito limitas yra mažesnis nei dabartinio nesumokėtos sumos klientui. Kredito limitas turi būti atleast {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +428,Please set account in Warehouse {0},Nustatykite sąskaitą sandėlyje {0}
apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,&quot;Remiantis&quot; ir &quot;grupę&quot; negali būti tas pats
DocType: Sales Person,Sales Person Targets,Pardavimų asmuo tikslai
DocType: Installation Note,IN-,VARŽYBOSE
DocType: Production Order Operation,In minutes,per kelias minutes
DocType: Issue,Resolution Date,geba data
DocType: Lab Test Template,Compound,Junginys
DocType: Student Batch Name,Batch Name,Serija Vardas
DocType: Fee Validity,Max number of visit,Maksimalus apsilankymo skaičius
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +339,Timesheet created:,Lapą sukurta:
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +913,Please set default Cash or Bank account in Mode of Payment {0},Prašome nustatyti numatytąją grynaisiais ar banko sąskaitą mokėjimo būdas {0}
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24,Enroll,įrašyti
DocType: GST Settings,GST Settings,GST Nustatymai
DocType: Selling Settings,Customer Naming By,Klientų įvardijimas Iki
DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Parodys studentą kaip pristatyti Studentų Mėnesio Lankomumas ataskaitos
DocType: Depreciation Schedule,Depreciation Amount,turto nusidėvėjimo suma
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56,Convert to Group,Konvertuoti į grupę
DocType: Delivery Trip,TOUR-.#####,TOUR -. #####
DocType: Activity Cost,Activity Type,veiklos rūšis
DocType: Request for Quotation,For individual supplier,Dėl individualaus tiekėjo
DocType: BOM Operation,Base Hour Rate(Company Currency),Bazinė valandą greičiu (Įmonės valiuta)
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,Paskelbta suma
DocType: Company,Fixed Days,Fiksuoto dienų
DocType: Quotation Item,Item Balance,Prekė balansas
DocType: Sales Invoice,Packing List,Pakavimo sąrašas
apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Užsakymų skiriamas tiekėjų.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43,Publishing,leidyba
DocType: Activity Cost,Projects User,projektai Vartotojas
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,Suvartojo
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +157,{0}: {1} not found in Invoice Details table,{0}: {1} nerasta Sąskaitos informacijos lentelės
DocType: Asset,Asset Owner Company,Turto savininko įmonė
DocType: Company,Round Off Cost Center,Suapvalinti sąnaudų centro
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Priežiūra Aplankykite {0} turi būti atšauktas prieš panaikinant šį pardavimo užsakymų
DocType: Asset Maintenance Log,AML-,AML-
DocType: Item,Material Transfer,medžiagos pernešimas
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24,Could not find path for ,Nepavyko rasti kelio
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +218,Opening (Dr),Atidarymas (dr)
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39,Posting timestamp must be after {0},Siunčiamos laiko žymos turi būti po {0}
apps/erpnext/erpnext/config/accounts.py +39,To make recurring documents,Sukurti pasikartojančius dokumentus
,GST Itemised Purchase Register,"Paaiškėjo, kad GST Detalios Pirkimo Registruotis"
DocType: Course Scheduling Tool,Reschedule,Iš naujo nustatytas
DocType: Employee Loan,Total Interest Payable,Iš viso palūkanų Mokėtina
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Įvežtinė kaina Mokesčiai ir rinkliavos
DocType: Production Order Operation,Actual Start Time,Tikrasis Pradžios laikas
DocType: BOM Operation,Operation Time,veikimo laikas
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +316,Finish,Baigti
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412,Base,Bazė
DocType: Timesheet,Total Billed Hours,Iš viso Apmokestintos valandos
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1463,Write Off Amount,Nurašyti suma
DocType: Leave Block List Allow,Allow User,leidžia vartotojui
DocType: Journal Entry,Bill No,Billas Nėra
DocType: Company,Gain/Loss Account on Asset Disposal,Pelnas / nuostolis paskyra nuo turto perdavimo
DocType: Vehicle Log,Service Details,paslaugų detalės
DocType: Vehicle Log,Service Details,paslaugų detalės
DocType: Subscription,Quarterly,kas ketvirtį
DocType: Lab Test Template,Grouped,Grupuojami
DocType: Selling Settings,Delivery Note Required,Reikalinga Važtaraštis
DocType: Bank Guarantee,Bank Guarantee Number,Banko garantija Taškų
DocType: Bank Guarantee,Bank Guarantee Number,Banko garantija Taškų
DocType: Assessment Criteria,Assessment Criteria,vertinimo kriterijai
DocType: BOM Item,Basic Rate (Company Currency),Bazinis tarifas (Įmonės valiuta)
DocType: Student Attendance,Student Attendance,Studentų dalyvavimas
DocType: Sales Invoice Timesheet,Time Sheet,laikas lapas
DocType: Manufacturing Settings,Backflush Raw Materials Based On,Backflush Žaliavos remiantis
DocType: Purchase Order Item Supplied,Reserve Warehouse,Rezervų sandėlis
DocType: Lead,Lead is an Organization,Švinas yra organizacija
DocType: Guardian Interest,Interest,palūkanos
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Pre Pardavimai
DocType: Instructor Log,Other Details,Kitos detalės
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,suplier
DocType: Lab Test,Test Template,Bandymo šablonas
DocType: Restaurant Order Entry Item,Served,Pateikta
apps/erpnext/erpnext/config/non_profit.py +13,Chapter information.,Skyrius informacija.
DocType: Account,Accounts,sąskaitos
DocType: Vehicle,Odometer Value (Last),Odometras Vertė (Paskutinis)
apps/erpnext/erpnext/config/buying.py +160,Templates of supplier scorecard criteria.,Tiekimo rezultatų vertinimo kriterijų šablonai.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109,Marketing,prekyba
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +290,Payment Entry is already created,Mokėjimo įrašas jau yra sukurta
DocType: Request for Quotation,Get Suppliers,Gaukite tiekėjus
DocType: Purchase Receipt Item Supplied,Current Stock,Dabartinis sandėlyje
apps/erpnext/erpnext/controllers/accounts_controller.py +609,Row #{0}: Asset {1} does not linked to Item {2},"Eilutės # {0}: Turto {1} nėra susijęs su straipsniais, {2}"
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394,Preview Salary Slip,Peržiūrėti darbo užmokestį
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54,Account {0} has been entered multiple times,Sąskaita {0} buvo įrašytas kelis kartus
DocType: Account,Expenses Included In Valuation,"Sąnaudų, įtrauktų Vertinimo"
apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +37,You can only renew if your membership expires within 30 days,Galite atnaujinti tik jei narystės terminas baigiasi per 30 dienų
DocType: Land Unit,Longitude,Ilguma
,Absent Student Report,Nėra studento ataskaitos
DocType: Crop,Crop Spacing UOM,Crop Spacing UOM
DocType: Email Digest,Next email will be sent on:,Kitas laiškas bus išsiųstas į:
DocType: Offer Letter Term,Offer Letter Term,Laiško su pasiūlymu terminas
DocType: Supplier Scorecard,Per Week,Per savaitę
apps/erpnext/erpnext/stock/doctype/item/item.py +639,Item has variants.,Prekė turi variantus.
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Viso studento
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,Prekė {0} nerastas
DocType: Bin,Stock Value,vertybinių popierių kaina
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +42,Fee records will be created in the background. In case of any error the error message will be updated in the Schedule.,Mokesčių įrašai bus sukurti fone. Bet kokios klaidos atveju klaidos pranešimas bus atnaujintas Tvarkaraštyje.
apps/erpnext/erpnext/accounts/doctype/account/account.py +239,Company {0} does not exist,Įmonės {0} neegzistuoja
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40,{0} has fee validity till {1},{0} mokestis galioja iki {1}
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +57,Tree Type,medis tipas
DocType: BOM Explosion Item,Qty Consumed Per Unit,Kiekis Suvartoti Vieneto
DocType: GST Account,IGST Account,IGST sąskaita
DocType: Serial No,Warranty Expiry Date,Garantija Galiojimo data
DocType: Material Request Item,Quantity and Warehouse,Kiekis ir sandėliavimo
DocType: Hub Settings,Unregister,Atsisakyti registracijos
DocType: Sales Invoice,Commission Rate (%),Komisija tarifas (%)
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,Prašome pasirinkti programą
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,Prašome pasirinkti programą
DocType: Project,Estimated Cost,Numatoma kaina
DocType: Purchase Order,Link to material requests,Nuoroda į materialinių prašymus
DocType: Hub Settings,Publish,Paskelbti
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7,Aerospace,Aviacija
DocType: Journal Entry,Credit Card Entry,Kreditinė kortelė įrašas
apps/erpnext/erpnext/config/accounts.py +57,Company and Accounts,Įmonė ir sąskaitos
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68,In Value,vertės
apps/erpnext/erpnext/utilities/transaction_base.py +33,Invalid Posting Time,Neteisingas skelbimo laikas
DocType: Lead,Campaign Name,kampanijos pavadinimas
DocType: Selling Settings,Close Opportunity After Days,Uždaryti progą dienų
,Reserved,rezervuotas
DocType: Driver,License Details,Informacija apie licenciją
DocType: Purchase Order,Supply Raw Materials,Tiekimo Žaliavos
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Turimas turtas
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +104,{0} is not a stock Item,{0} nėra sandėlyje punktas
apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',"Prašome pasidalinti savo atsiliepimais su mokymu spustelėdami &quot;Mokymo atsiliepimai&quot;, tada &quot;Naujas&quot;"
DocType: Mode of Payment Account,Default Account,numatytoji paskyra
apps/erpnext/erpnext/stock/doctype/item/item.py +262,Please select Sample Retention Warehouse in Stock Settings first,Pirmiausia pasirinkite &quot;Sample Storage Warehouse&quot; atsargų nustatymuose
DocType: Payment Entry,Received Amount (Company Currency),Gautos sumos (Įmonės valiuta)
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,Lead must be set if Opportunity is made from Lead,"Švinas turi būti nustatyti, jei galimybės yra pagamintas iš švino"
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29,Please select weekly off day,Prašome pasirinkti savaitę nuo dieną
DocType: Patient,O Negative,O neigiamas
DocType: Production Order Operation,Planned End Time,Planuojamas Pabaigos laikas
,Sales Person Target Variance Item Group-Wise,Pardavimų Asmuo Tikslinė Dispersija punktas grupė-Išminčius
apps/erpnext/erpnext/accounts/doctype/account/account.py +93,Account with existing transaction cannot be converted to ledger,Sąskaita su esamais sandoris negali būti konvertuojamos į sąskaitų knygos
apps/erpnext/erpnext/config/non_profit.py +33,Memebership Type Details,Mokesčių tipo duomenys
DocType: Delivery Note,Customer's Purchase Order No,Kliento Užsakymo Nėra
DocType: Budget,Budget Against,biudžeto prieš
DocType: Employee,Cell Number,Telefono numeris
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +445,There's no employee for the given criteria. Check that Salary Slips have not already been created.,"Nė vienas darbuotojas pagal nurodytus kriterijus nėra. Patikrinkite, ar atlyginimų čekiai dar nebuvo sukurti."
apps/erpnext/erpnext/stock/reorder_item.py +194,Auto Material Requests Generated,Auto Medžiaga Prašymai Sugeneruoti
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,prarastas
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +150,You can not enter current voucher in 'Against Journal Entry' column,Jūs negalite įvesti dabartinį kuponą į &quot;prieš leidinys įrašas&quot; skiltyje
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Skirta gamybos
DocType: Soil Texture,Sand,Smėlis
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25,Energy,energija
DocType: Opportunity,Opportunity From,galimybė Nuo
apps/erpnext/erpnext/config/hr.py +98,Monthly salary statement.,Mėnesinis darbo užmokestis pareiškimas.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +874,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Eilutė {0}: {1} {2} elementui reikalingi eilės numeriai. Jūs pateikė {3}.
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79,Please select a table,Pasirinkite lentelę
DocType: BOM,Website Specifications,Interneto svetainė duomenys
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78,{0} is an invalid email address in 'Recipients',{0} yra netinkamas el. Pašto adresas &quot;gavėjams&quot;
DocType: Special Test Items,Particulars,Duomenys
apps/erpnext/erpnext/config/healthcare.py +144,Antibiotic.,Antibiotikas.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24,{0}: From {0} of type {1},{0}: Nuo {0} tipo {1}
DocType: Warranty Claim,CI-,CI-
apps/erpnext/erpnext/controllers/buying_controller.py +310,Row {0}: Conversion Factor is mandatory,Eilutės {0}: konversijos faktorius yra privalomas
DocType: Student,A+,A +
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +326,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Keli Kaina Taisyklės egzistuoja tais pačiais kriterijais, prašome išspręsti konfliktą suteikti pirmenybę. Kaina Taisyklės: {0}"
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +504,Cannot deactivate or cancel BOM as it is linked with other BOMs,Negalima išjungti arba atšaukti BOM kaip ji yra susijusi su kitais BOMs
DocType: Asset,Maintenance,priežiūra
DocType: Item Attribute Value,Item Attribute Value,Prekė Pavadinimas Reikšmė
DocType: Item,Maximum sample quantity that can be retained,"Maksimalus mėginių kiekis, kurį galima išsaugoti"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +398,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Eilutė {0} # Item {1} negalima perkelti daugiau nei {2} prieš pirkimo užsakymą {3}
apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Pardavimų kampanijas.
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +117,Make Timesheet,Padaryti žiniaraštis
DocType: Sales Taxes and Charges Template,"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.

#### Note

The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","Standartinė mokestis šablonas, kuris gali būti taikomas visiems pardavimo sandorių. Šis šablonas gali būti sąrašą mokesčių vadovų, taip pat kitų išlaidų / pajamų vadovų, pavyzdžiui, &quot;Pristatymas&quot;, &quot;Draudimas&quot;, &quot;tvarkymas&quot; ir tt #### Pastaba mokesčio tarifas, kurį nurodote čia bus standartinis mokesčio tarifas už visus ** Daiktai **. Jei yra ** daiktai **, kurios turi skirtingus tarifus, jie turi būti pridėta ** Prekės mokesčio ** lentelę ** Prekės ** meistras. #### Aprašymas Stulpeliai 1. Skaičiavimo tipas: - Tai gali būti ** Grynasis Viso ** (tai yra bazinio dydžio suma). - ** Dėl ankstesnės eilės viso / suma ** (kumuliacinį mokesčius ar rinkliavas). Jei pasirinksite šią parinktį, mokestis bus taikomas kaip ankstesnės eilės procentais (mokesčių lentelę) sumos arba iš viso. - ** Tikrasis ** (kaip minėta). 2. Sąskaitos vadovas: Sąskaitos knygos, pagal kurią šis mokestis bus nubaustas 3. Sąnaudų centras: Jei mokestis / mokestis yra pajamų (pavyzdžiui, laivybos) arba išlaidų ji turi būti nubaustas nuo išlaidų centro. 4. Aprašymas: Aprašymas mokesčio (kuris bus spausdinamas sąskaitų faktūrų / kabučių). 5. Vertinti: Mokesčio tarifas. 6. Suma: Mokesčių suma. 7. Iš viso: Kaupiamasis viso šio taško. 8. Įveskite Row: Jei remiantis &quot;ankstesnės eilės viso&quot; galite pasirinkti numerį eilutės, kurios bus imtasi kaip pagrindą šiam apskaičiavimui (pagal nutylėjimą yra ankstesnė eilutė). 9. Ar šis mokestis įtrauktas į bazinę palūkanų normą ?: Jei pažymėsite šią, tai reiškia, kad šis mokestis nebus rodomas žemiau punkto lentelėje, bet bus įtrauktas į bazinę kainą savo pagrindinio punkto lentelėje. Tai naudinga, kai norite suteikti plokščią kainą (įskaitant visus mokesčius) kaina vartotojams."
DocType: Employee,Bank A/C No.,Bank A / C Nr
DocType: Bank Guarantee,Project,projektas
DocType: Quality Inspection Reading,Reading 7,Skaitymas 7
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9,Partially Ordered,dalinai Užsakytas
DocType: Lab Test,Lab Test,Laboratorijos testas
DocType: Expense Claim Detail,Expense Claim Type,Kompensuojamos Paraiškos tipas
DocType: Shopping Cart Settings,Default settings for Shopping Cart,Numatytieji nustatymai krepšelį
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +26,Add Timeslots,Pridėti &quot;Timeslots&quot;
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Turto sunaikintas per žurnalo įrašą {0}
DocType: Employee Loan,Interest Income Account,Palūkanų pajamų sąskaita
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58,Review Invitation Sent,Išsiųsta pakvietimo peržiūra
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13,Biotechnology,biotechnologijos
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Office Maintenance Expenses,Biuro išlaikymo sąnaudos
apps/erpnext/erpnext/utilities/user_progress.py +51,Go to ,Eiti į
apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Įsteigti pašto dėžutę
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +114,Please enter Item first,Prašome įvesti Elementą pirmas
DocType: Asset Repair,Downtime,Prastovos laikas
DocType: Account,Liability,atsakomybė
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +234,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankcijos suma negali būti didesnė nei ieškinio suma eilutėje {0}.
DocType: Salary Detail,Do not include in total,Neįtraukite iš viso
DocType: Company,Default Cost of Goods Sold Account,Numatytasis išlaidos parduotų prekių sąskaita
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +997,Sample quantity {0} cannot be more than received quantity {1},Mėginio kiekis {0} negali būti didesnis nei gautas kiekis {1}
apps/erpnext/erpnext/stock/get_item_details.py +367,Price List not selected,Kainų sąrašas nepasirinkote
DocType: Employee,Family Background,šeimos faktai
DocType: Request for Quotation Supplier,Send Email,Siųsti laišką
apps/erpnext/erpnext/stock/doctype/item/item.py +218,Warning: Invalid Attachment {0},Įspėjimas: Neteisingas Priedas {0}
DocType: Item,Max Sample Quantity,Maksimalus mėginio kiekis
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +764,No Permission,Nėra leidimo
apps/erpnext/erpnext/hub_node/page/hub/hub.js +438,Quote Requested,Citata prašoma
DocType: Vital Signs,Heart Rate / Pulse,Širdies ritmas / impulsas
DocType: Company,Default Bank Account,Numatytasis banko sąskaitos
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +55,"To filter based on Party, select Party Type first","Filtruoti remiantis partijos, pasirinkite Šalis Įveskite pirmą"
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48,'Update Stock' can not be checked because items are not delivered via {0},"&quot;Atnaujinti sandėlyje&quot; negali būti patikrinta, nes daiktų nėra pristatomos per {0}"
DocType: Vehicle,Acquisition Date,įsigijimo data
apps/erpnext/erpnext/utilities/user_progress.py +143,Nos,nos
DocType: Item,Items with higher weightage will be shown higher,"Daiktai, turintys aukštąjį weightage bus rodomas didesnis"
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests and Vital Signs,Lab testus ir gyvybinius požymius
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Bankas Susitaikymas detalės
apps/erpnext/erpnext/controllers/accounts_controller.py +613,Row #{0}: Asset {1} must be submitted,Eilutės # {0}: Turto {1} turi būti pateiktas
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,Nėra darbuotojas nerasta
DocType: Subscription,Stopped,sustabdyta
DocType: Item,If subcontracted to a vendor,Jei subrangos sutartį pardavėjas
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111,Student Group is already updated.,Studentų grupė jau yra atnaujinama.
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111,Student Group is already updated.,Studentų grupė jau yra atnaujinama.
DocType: SMS Center,All Customer Contact,Viskas Klientų Susisiekite
DocType: Land Unit,Tree Details,medis detalės
DocType: Training Event,Event Status,Statusas renginiai
DocType: Volunteer,Availability Timeslot,Prieinamumo laikraštis
,Support Analytics,paramos Analytics &quot;
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +352,"If you have any questions, please get back to us.","Jei turite kokių nors klausimų, prašome grįžti į mus."
DocType: Item,Website Warehouse,Interneto svetainė sandėlis
DocType: Payment Reconciliation,Minimum Invoice Amount,Minimalus sąskaitos faktūros suma
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Kaina centras {2} nepriklauso Company {3}
apps/erpnext/erpnext/utilities/user_progress.py +89,Upload your letter head (Keep it web friendly as 900px by 100px),Įkelkite savo laiško galva (laikykite jį tinkamu kaip 900 pikselių 100 pikselių)
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88,{0} {1}: Account {2} cannot be a Group,{0} {1}: Sąskaitos {2} negali būti Grupė
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table,Prekė eilutė {IDX}: {DOCTYPE} {DOCNAME} neegzistuoja viršaus &quot;{DOCTYPE}&quot; stalo
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +284,Timesheet {0} is already completed or cancelled,Lapą {0} jau baigė arba atšaukti
apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,nėra užduotys
DocType: Item Variant Settings,Copy Fields to Variant,Kopijuoti laukus į variantą
DocType: Asset,Opening Accumulated Depreciation,Atidarymo sukauptas nusidėvėjimas
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49,Score must be less than or equal to 5,Rezultatas turi būti mažesnis arba lygus 5
DocType: Program Enrollment Tool,Program Enrollment Tool,Programos Įrašas įrankis
apps/erpnext/erpnext/config/accounts.py +335,C-Form records,"įrašų, C-forma"
apps/erpnext/erpnext/config/selling.py +311,Customer and Supplier,Klientų ir tiekėjas
DocType: Email Digest,Email Digest Settings,Siųsti Digest Nustatymai
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +354,Thank you for your business!,Dėkoju Jums už bendradarbiavimą!
apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Paramos užklausos iš klientų.
DocType: Setup Progress Action,Action Doctype,&quot;Action Doctype&quot;
,Production Order Stock Report,Gamybos Užsakyti sandėlyje ataskaita
apps/erpnext/erpnext/config/healthcare.py +149,Sensitivity Naming.,Jautrumo vardas.
DocType: HR Settings,Retirement Age,pensijinis amžius
DocType: Bin,Moving Average Rate,Moving Average Balsuok
DocType: Production Planning Tool,Select Items,pasirinkite prekę
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +370,{0} against Bill {1} dated {2},{0} prieš Bill {1} {2} data
apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Institution,Sąrankos institucija
DocType: Program Enrollment,Vehicle/Bus Number,Transporto priemonė / autobusai Taškų
apps/erpnext/erpnext/education/doctype/course/course.js +17,Course Schedule,Žinoma Tvarkaraštis
DocType: Request for Quotation Supplier,Quote Status,Citata statusas
DocType: Maintenance Visit,Completion Status,užbaigimo būsena
DocType: HR Settings,Enter retirement age in years,Įveskite pensinį amžių metais
DocType: Crop,Target Warehouse,Tikslinė sandėlis
DocType: Payroll Employee Detail,Payroll Employee Detail,Išsami darbo užmokesčio darbuotojo informacija
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128,Please select a warehouse,Prašome pasirinkti sandėlį
DocType: Cheque Print Template,Starting location from left edge,Nuo vietą iš kairiojo krašto
DocType: Item,Allow over delivery or receipt upto this percent,Leisti per pristatymą ar gavimo net iki šio proc
DocType: Stock Entry,STE-,STE-
DocType: Upload Attendance,Import Attendance,importas Lankomumas
apps/erpnext/erpnext/public/js/pos/pos.html +113,All Item Groups,Visi punktas Grupės
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Net Profit / Loss,Grynasis pelnas / nuostolis
apps/erpnext/erpnext/config/setup.py +89,Automatically compose message on submission of transactions.,Automatiškai kurti pranešimą pateikus sandorius.
DocType: Production Order,Item To Manufacture,Prekė Gamyba
apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} statusas {2}
DocType: Water Analysis,Collection Temperature ,Kolekcijos temperatūra
DocType: Employee,Provide Email Address registered in company,Pateikite registruota bendrovė pašto adresą
DocType: Shopping Cart Settings,Enable Checkout,Įjungti Checkout
apps/erpnext/erpnext/config/learn.py +202,Purchase Order to Payment,Pirkimo užsakymas su mokėjimo
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,"prognozuojama, Kiekis"
DocType: Sales Invoice,Payment Due Date,Sumokėti iki
DocType: Drug Prescription,Interval UOM,Intervalas UOM
apps/erpnext/erpnext/stock/doctype/item/item.js +490,Item Variant {0} already exists with same attributes,Prekė variantas {0} jau egzistuoja su tais pačiais atributais
DocType: Item,Hub Publishing Details,Hub Publishing duomenys
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +115,'Opening',&quot;Atidarymas&quot;
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Atidarykite daryti
DocType: Notification Control,Delivery Note Message,Važtaraštis pranešimas
DocType: Lab Test Template,Result Format,Rezultato formatas
DocType: Expense Claim,Expenses,išlaidos
DocType: Delivery Stop,Delivery Notes,Pristatymo pastabos
DocType: Item Variant Attribute,Item Variant Attribute,Prekė variantas Įgūdis
,Purchase Receipt Trends,Pirkimo kvito tendencijos
DocType: Payroll Entry,Bimonthly,Dviejų mėnesių
DocType: Vehicle Service,Brake Pad,stabdžių bloknotas
DocType: Fertilizer,Fertilizer Contents,Trąšų turinys
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119,Research & Development,Tyrimai ir plėtra
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Suma Bill
DocType: Company,Registration Details,Registracija detalės
DocType: Timesheet,Total Billed Amount,Iš viso mokesčio suma
DocType: Item Reorder,Re-Order Qty,Re Užsakomas kiekis
DocType: Leave Block List Date,Leave Block List Date,Palikite Blokuoti sąrašą data
DocType: Pricing Rule,Price or Discount,Kaina arba nuolaida
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +91,BOM #{0}: Raw material cannot be same as main Item,BOM # {0}: žaliava negali būti tokia pati kaip pagrindinis elementas
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,Iš viso taikomi mokesčiai į pirkimo kvito sumų lentelė turi būti tokios pačios kaip viso mokesčių ir rinkliavų
DocType: Sales Team,Incentives,paskatos
apps/erpnext/erpnext/hub_node/page/hub/hub.js +64,Register for Hub,Užsiregistruokite Hub
DocType: SMS Log,Requested Numbers,Pageidaujami numeriai
DocType: Volunteer,Evening,Vakaras
DocType: Production Planning Tool,Only Obtain Raw Materials,Gauti tik žaliavų panaudojimas
DocType: Customer,Bypass credit limit check at Sales Order,Apskaičiuokite kredito limito patikrinimą Pardavimų užsakyme
apps/erpnext/erpnext/config/hr.py +147,Performance appraisal.,Veiklos vertinimas.
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +97,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Įjungus &quot;Naudokite krepšelį&quot;, kaip Krepšelis yra įjungtas ir ten turėtų būti bent viena Mokesčių taisyklė krepšelį"
apps/erpnext/erpnext/controllers/accounts_controller.py +411,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Mokėjimo Įėjimo {0} yra susijęs su ordino {1}, patikrinti, ar jis turi būti traukiamas kaip anksto šioje sąskaitoje faktūroje."
DocType: Sales Invoice Item,Stock Details,akcijų detalės
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,projekto vertė
apps/erpnext/erpnext/config/selling.py +321,Point-of-Sale,Pardavimo punktas
DocType: Fee Schedule,Fee Creation Status,Mokesčio kūrimo būsena
DocType: Vehicle Log,Odometer Reading,odometro parodymus
apps/erpnext/erpnext/accounts/doctype/account/account.py +116,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Sąskaitos likutis jau kredito, jums neleidžiama nustatyti &quot;Balansas turi būti&quot; kaip &quot;debeto&quot;"
DocType: Account,Balance must be,Balansas turi būti
DocType: Hub Settings,Publish Pricing,Paskelbti Kainos
DocType: Notification Control,Expense Claim Rejected Message,Kompensuojamos teiginys atmetamas pranešimas
,Available Qty,Turimas Kiekis
DocType: Purchase Taxes and Charges,On Previous Row Total,Dėl ankstesnės eilės viso
DocType: Purchase Invoice Item,Rejected Qty,atmesta Kiekis
DocType: Setup Progress Action,Action Field,Veiksmų laukas
DocType: Healthcare Settings,Manage Customer,Valdyti klientą
DocType: Delivery Trip,Delivery Stops,Pristatymas sustoja
DocType: Salary Slip,Working Days,Darbo dienos
DocType: Serial No,Incoming Rate,Priimamojo Balsuok
DocType: Packing Slip,Gross Weight,Bendras svoris
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47,Enable Hub,Įgalinti koncentratorių
apps/erpnext/erpnext/public/js/setup_wizard.js +110,The name of your company for which you are setting up this system.,"Jūsų įmonės pavadinimas, dėl kurių jūs nustatote šią sistemą."
DocType: HR Settings,Include holidays in Total no. of Working Days,Įtraukti atostogas iš viso ne. darbo dienų
apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108,Setup your Institute in ERPNext,Nustatykite savo institutą ERPNext
DocType: Agriculture Analysis Criteria,Plant Analysis,Augalų analizė
DocType: Job Applicant,Hold,laikyti
DocType: Employee,Date of Joining,Data Prisijungimas
DocType: Naming Series,Update Series,Atnaujinti serija
DocType: Supplier Quotation,Is Subcontracted,subrangos sutartis
DocType: Restaurant Table,Minimum Seating,Minimali sėdimoji vietovė
DocType: Item Attribute,Item Attribute Values,Prekė atributų reikšmes
DocType: Examination Result,Examination Result,tyrimo rezultatas
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +843,Purchase Receipt,pirkimo kvito
,Received Items To Be Billed,Gauti duomenys turi būti apmokestinama
apps/erpnext/erpnext/config/accounts.py +303,Currency exchange rate master.,Valiutos kursas meistras.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +198,Reference Doctype must be one of {0},Nuoroda Dokumento tipo turi būti vienas iš {0}
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +322,Unable to find Time Slot in the next {0} days for Operation {1},Nepavyko rasti laiko tarpsnių per ateinančius {0} dienų darbui {1}
DocType: Production Order,Plan material for sub-assemblies,Planas medžiaga mazgams
apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,Pardavimų Partneriai ir teritorija
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +585,BOM {0} must be active,BOM {0} turi būti aktyvus
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +193,Closing (Opening + Total),Uždarymas (atidarymas + viso)
DocType: Journal Entry,Depreciation Entry,Nusidėvėjimas įrašas
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +36,Please select the document type first,Prašome pasirinkti dokumento tipą pirmas
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +111,Print in Account Currency,Spausdinti sąskaitos valiuta
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Atšaukti Medžiaga Apsilankymai {0} prieš atšaukiant šią Priežiūros vizitas
DocType: Crop Cycle,ISO 8016 standard,ISO 8016 standartas
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,Serial No {0} does not belong to Item {1},Serijos Nr {0} nepriklauso punkte {1}
DocType: Purchase Receipt Item Supplied,Required Qty,Reikalinga Kiekis
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +127,Warehouses with existing transaction can not be converted to ledger.,Sandėliai su esamais sandoris negali būti konvertuojamos į knygą.
DocType: Bank Reconciliation,Total Amount,Visas kiekis
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32,Internet Publishing,Interneto leidyba
DocType: Prescription Duration,Number,Numeris
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25,Creating {0} Invoice,Kuriama {0} sąskaita faktūra
DocType: Medical Code,Medical Code Standard,Medicinos kodekso standartas
DocType: Soil Texture,Clay Composition (%),Molio sudėtis (%)
DocType: Production Planning Tool,Production Orders,gamybos užsakymus
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81,Please save before assigning task.,Prašome išsaugoti prieš priskirdami užduotį.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72,Balance Value,balansinė vertė
DocType: Lab Test,Lab Technician,Laboratorijos technikas
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Pardavimų Kainų sąrašas
DocType: Healthcare Settings,"If checked, a customer will be created, mapped to Patient.
Patient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.","Jei pažymėsite, klientas bus sukurtas, priskirtas pacientui. Paciento sąskaita bus sukurta prieš šį Klientą. Kuriant pacientą galite pasirinkti esamą klientą."
DocType: Bank Reconciliation,Account Currency,sąskaita Valiuta
DocType: Lab Test,Sample ID,Pavyzdžio ID
apps/erpnext/erpnext/accounts/general_ledger.py +165,Please mention Round Off Account in Company,Paminėkite suapvalinti Narystė Bendrovėje
DocType: Purchase Receipt,Range,diapazonas
DocType: Supplier,Default Payable Accounts,Numatytieji mokėtinų sumų
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49,Employee {0} is not active or does not exist,Darbuotojų {0} is not active arba neegzistuoja
DocType: Fee Structure,Components,komponentai
apps/erpnext/erpnext/assets/doctype/asset/asset.py +276,Please enter Asset Category in Item {0},Prašome įvesti Turto kategorija prekės {0}
apps/erpnext/erpnext/stock/doctype/item/item.py +634,Item Variants {0} updated,Prekė Variantai {0} atnaujinama
DocType: Quality Inspection Reading,Reading 6,Skaitymas 6
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9,"to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field
of this","turi būti sukurta. Jei vėluojama, turėsite rankiniu būdu pakeisti lauko &quot;Kartoti mėnesio dieną&quot; lauką"
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +945,Cannot {0} {1} {2} without any negative outstanding invoice,Negaliu {0} {1} {2} be jokio neigiamo išskirtinis sąskaita
DocType: Purchase Invoice Advance,Purchase Invoice Advance,Pirkimo faktūros Advance
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +197,Row {0}: Credit entry can not be linked with a {1},Eilutės {0}: Kredito įrašas negali būti susieta su {1}
apps/erpnext/erpnext/config/accounts.py +246,Define budget for a financial year.,Nustatykite biudžetą per finansinius metus.
DocType: Mode of Payment Account,Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,"Numatytasis Bankas / Pinigų sąskaita bus automatiškai atnaujinta POS sąskaita faktūra, kai pasirinktas šis būdas."
DocType: Lead,LEAD-,VADOVAUTI-
DocType: Employee,Permanent Address Is,Nuolatinė adresas
DocType: Production Order Operation,Operation completed for how many finished goods?,"Operacija baigta, kaip daug gatavų prekių?"
DocType: Payment Terms Template,Payment Terms Template,Mokėjimo sąlygos šablonas
apps/erpnext/erpnext/public/js/setup_wizard.js +51,The Brand,Brand
DocType: Employee,Exit Interview Details,Išeiti Interviu detalės
DocType: Item,Is Purchase Item,Ar pirkimas Prekės
DocType: Journal Entry Account,Purchase Invoice,pirkimo sąskaita faktūra
DocType: Stock Ledger Entry,Voucher Detail No,Bon Išsamiau Nėra
apps/erpnext/erpnext/accounts/page/pos/pos.js +781,New Sales Invoice,Nauja pardavimo sąskaita-faktūra
DocType: Stock Entry,Total Outgoing Value,Iš viso Siuntimo kaina
DocType: Physician,Appointments,Paskyrimai
apps/erpnext/erpnext/public/js/account_tree_grid.js +224,Opening Date and Closing Date should be within same Fiscal Year,Atidarymo data ir galutinis terminas turėtų būti per patį finansiniams metams
DocType: Lead,Request for Information,Paprašyti informacijos
,LeaderBoard,Lyderių
DocType: Sales Invoice Item,Rate With Margin (Company Currency),Norma su marža (įmonės valiuta)
apps/erpnext/erpnext/accounts/page/pos/pos.js +794,Sync Offline Invoices,Sinchronizuoti Atsijungęs Sąskaitos
DocType: Payment Request,Paid,Mokama
DocType: Program Fee,Program Fee,programos mokestis
DocType: BOM Update Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.
It also updates latest price in all the BOMs.","Pakeiskite tam tikrą BOM visose kitose BOM, kur jis naudojamas. Jis pakeis seną BOM nuorodą, atnaujins kainą ir atkurs &quot;BOM sprogimo elementą&quot; lentelę pagal naują BOM. Taip pat atnaujinama naujausia kaina visose BOM."
DocType: Salary Slip,Total in words,Iš viso žodžiais
DocType: Material Request Item,Lead Time Date,Švinas Laikas Data
DocType: Guardian,Guardian Name,globėjas Vardas
DocType: Cheque Print Template,Has Print Format,Ar spausdintos
DocType: Employee Loan,Sanctioned,sankcijos
apps/erpnext/erpnext/accounts/page/pos/pos.js +75, is mandatory. Maybe Currency Exchange record is not created for ,yra privaloma. Gal valiutų įrašas nėra sukurtas
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +122,Row #{0}: Please specify Serial No for Item {1},Eilutės # {0}: Prašome nurodyti Serijos Nr už prekę {1}
DocType: Crop Cycle,Crop Cycle,Pasėlių ciklas
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +632,"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.","Dėl &quot;produktas Bundle reikmenys, sandėlis, Serijos Nr paketais Nėra bus laikomas iš&quot; apyrašas stalo &quot;. Jei Sandėlio ir Serija Ne yra vienoda visoms pakavimo jokių daiktų &quot;produktas Bundle&quot; elemento, tos vertės gali būti įrašoma į pagrindinę punkto lentelėje, vertės bus nukopijuoti į &quot;apyrašas stalo."
DocType: Student Admission,Publish on website,Skelbti tinklapyje
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651,Supplier Invoice Date cannot be greater than Posting Date,Tiekėjas sąskaitos faktūros išrašymo data negali būti didesnis nei Skelbimo data
DocType: Purchase Invoice Item,Purchase Order Item,Pirkimui užsakyti Elementą
DocType: Agriculture Task,Agriculture Task,Žemės ūkio užduotis
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Indirect Income,netiesioginė pajamos
DocType: Student Attendance Tool,Student Attendance Tool,Studentų dalyvavimas įrankis
DocType: Restaurant Menu,Price List (Auto created),Kainoraštis (automatiškai sukurta)
DocType: Cheque Print Template,Date Settings,data Nustatymai
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,variantiškumas
,Company Name,Įmonės pavadinimas
DocType: SMS Center,Total Message(s),Bendras pranešimas (-ai)
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +917,Select Item for Transfer,Pasirinkite punktas perkelti
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Nustatymų seriją galite nustatyti {0} naudodami sąranką&gt; Nustatymai&gt; vardų serija
DocType: Purchase Invoice,Additional Discount Percentage,Papildoma nuolaida procentais
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Peržiūrėkite visas pagalbos video sąrašą
DocType: Agriculture Analysis Criteria,Soil Texture,Dirvožemio tekstūra
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,Pasirinkite sąskaita Banko vadovas kurioje patikrinimas buvo deponuoti.
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Leisti vartotojui redaguoti kainoraštį Balsuok sandoriuose
DocType: Pricing Rule,Max Qty,Maksimalus Kiekis
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30,"Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \
						Please enter a valid Invoice","Eilutės {0}: Sąskaita {1} yra negaliojantis, jis gali būti atšauktas / neegzistuoja. \ Prašome įvesti galiojantį sąskaita faktūra"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Eilutės {0}: Mokėjimo prieš pirkimo / pardavimo ordino visada turi būti pažymėtas kaip anksto
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16,Chemical,cheminis
DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,"Numatytasis Bankas / Pinigų sąskaita bus automatiškai atnaujinta užmokesčių žurnalo įrašą, kai pasirinktas šis būdas."
DocType: BOM,Raw Material Cost(Company Currency),Žaliavų kaina (Įmonės valiuta)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +775,All items have already been transferred for this Production Order.,Visos prekės jau buvo pervestos šios produkcijos įsakymu.
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +87,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Eilutė # {0}: Įvertinti gali būti ne didesnis nei naudotu dydžiu {1} {2}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +87,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Eilutė # {0}: Įvertinti gali būti ne didesnis nei naudotu dydžiu {1} {2}
apps/erpnext/erpnext/utilities/user_progress.py +144,Meter,matuoklis
DocType: Workstation,Electricity Cost,elektros kaina
DocType: HR Settings,Don't send Employee Birthday Reminders,Nesiųskite Darbuotojų Gimimo diena Priminimai
DocType: Expense Claim,Total Advance Amount,Visa avansinė suma
DocType: Delivery Stop,Estimated Arrival,Numatytas atvykimas
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34,Save Settings,Išsaugoti nustatymus
DocType: Delivery Stop,Notified by Email,Pranešta el. Paštu
apps/erpnext/erpnext/hub_node/page/hub/hub.js +683,Requested Products,Prašomi produktai
DocType: Item,Inspection Criteria,tikrinimo kriterijai
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,pervestos
DocType: BOM Website Item,BOM Website Item,BOM svetainė punktas
apps/erpnext/erpnext/public/js/setup_wizard.js +52,Upload your letter head and logo. (you can edit them later).,Įkelti savo laiške galvą ir logotipą. (Galite redaguoti juos vėliau).
DocType: Timesheet Detail,Bill,sąskaita
apps/erpnext/erpnext/assets/doctype/asset/asset.py +88,Next Depreciation Date is entered as past date,Kitas Nusidėvėjimas data yra įvesta kaip praeities datos
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208,White,baltas
DocType: SMS Center,All Lead (Open),Visi švinas (Atviras)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +253,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Eilutės {0}: Kiekis neprieinama {4} sandėlyje {1} ne komandiruotės laiką įrašo ({2} {3})
DocType: Purchase Invoice,Get Advances Paid,Gauti avansai Mokama
DocType: Item,Automatically Create New Batch,Automatiškai Sukurti naują partiją
DocType: Item,Automatically Create New Batch,Automatiškai Sukurti naują partiją
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +808,Make ,padaryti
DocType: Student Admission,Admission Start Date,Priėmimo pradžios data
DocType: Journal Entry,Total Amount in Words,Iš viso suma žodžiais
apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29,New Employee,Naujas darbuotojas
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.,"Įvyko klaida. Vienas tikėtina priežastis gali būti, kad jūs neišsaugojote formą. Prašome susisiekti su support@erpnext.com jei problema išlieka."
apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Mano krepšelis
apps/erpnext/erpnext/controllers/selling_controller.py +129,Order Type must be one of {0},Pavedimo tipas turi būti vienas iš {0}
DocType: Lead,Next Contact Date,Kitas Kontaktinė data
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Opening Qty,atidarymo Kiekis
DocType: Healthcare Settings,Appointment Reminder,Paskyrimų priminimas
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +465,Please enter Account for Change Amount,Prašome įvesti sąskaitą pokyčio sumą
DocType: Program Enrollment Tool Student,Student Batch Name,Studentų Serija Vardas
DocType: Consultation,Doctor,Gydytojas
DocType: Holiday List,Holiday List Name,Atostogų sąrašas Vardas
DocType: Repayment Schedule,Balance Loan Amount,Balansas Paskolos suma
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,Tvarkaraštis Kurso
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234,Stock Options,Akcijų pasirinkimai
DocType: Buying Settings,Disable Fetching Last Purchase Details in Purchase Order,Neleisti gauti paskutinių pirkimo duomenų pirkimo užsakyme
DocType: Journal Entry Account,Expense Claim,Kompensuojamos Pretenzija
apps/erpnext/erpnext/assets/doctype/asset/asset.js +254,Do you really want to restore this scrapped asset?,Ar tikrai norite atstatyti šį metalo laužą turtą?
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +381,Qty for {0},Kiekis dėl {0}
DocType: Leave Application,Leave Application,atostogos taikymas
DocType: Patient,Patient Relation,Paciento santykis
apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Palikite Allocation įrankis
DocType: Item,Hub Category to Publish,Hub kategorija paskelbti
DocType: Leave Block List,Leave Block List Dates,Palikite blokuojamų sąrašą Datos
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Nustatykite numerių seriją lankytojams per sąranką&gt; numeravimo serija
DocType: Sales Invoice,Billing Address GSTIN,Atsiskaitymo adresas GSTIN
DocType: Assessment Plan,Evaluate,Įvertinti
DocType: Workstation,Net Hour Rate,Grynasis valandą greičiu
DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Nusileido Kaina pirkimas gavimas
DocType: Company,Default Terms,numatytieji sąlygos
DocType: Supplier Scorecard Period,Criteria,Kriterijai
DocType: Packing Slip Item,Packing Slip Item,Pakavimo Kuponas punktas
DocType: Purchase Invoice,Cash/Bank Account,Pinigai / banko sąskaitos
apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},Nurodykite {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +73,Removed items with no change in quantity or value.,"Pašalinti elementai, be jokių kiekio ar vertės pokyčius."
DocType: Delivery Note,Delivery To,Pristatyti
apps/erpnext/erpnext/stock/doctype/item/item.js +384,Variant creation has been queued.,Variantų kūrimas buvo eilėje.
apps/erpnext/erpnext/stock/doctype/item/item.py +668,Attribute table is mandatory,Įgūdis lentelė yra privalomi
DocType: Production Planning Tool,Get Sales Orders,Gauk pardavimo užsakymus
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +67,{0} can not be negative,{0} negali būti neigiamas
DocType: Training Event,Self-Study,Savarankiškas mokymasis
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +544,Discount,Nuolaida
DocType: Membership,Membership,Narystė
DocType: Asset,Total Number of Depreciations,Viso nuvertinimai
DocType: Sales Invoice Item,Rate With Margin,Norma atsargos
DocType: Sales Invoice Item,Rate With Margin,Norma atsargos
DocType: Workstation,Wages,užmokestis
DocType: Asset Maintenance,Maintenance Manager Name,Techninės priežiūros vadybininko vardas
DocType: Agriculture Task,Urgent,skubus
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,Please specify a valid Row ID for row {0} in table {1},Nurodykite tinkamą Row ID eilės {0} lentelėje {1}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84,Unable to find variable: ,Neįmanoma rasti kintamojo:
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +746,Please select a field to edit from numpad,"Pasirinkite lauką, kurį norite redaguoti iš numpad"
apps/erpnext/erpnext/stock/doctype/item/item.py +253,Cannot be a fixed asset item as Stock Ledger is created.,"Negali būti elementas ilgalaikio turto, kaip sukuriamas atsargų vadovas."
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Eiti į Desktop ir pradėti naudoti ERPNext
DocType: Item,Manufacturer,gamintojas
DocType: Landed Cost Item,Purchase Receipt Item,Pirkimo kvito punktas
DocType: Purchase Receipt,PREC-RET-,PREC-RET-
DocType: POS Profile,Sales Invoice Payment,Pardavimų sąskaitų apmokėjimo
DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Reserved Sandėlis pardavimų užsakymų / Finished produkcijos sandėlis
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Selling Amount,Parduodami suma
DocType: Repayment Schedule,Interest Amount,palūkanų suma
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +120,You are the Expense Approver for this record. Please Update the 'Status' and Save,Jūs esate sąskaita Tvirtintojas už šio įrašo. Atnaujinkite parametras &quot;status&quot; ir sutaupykite
DocType: Serial No,Creation Document No,Kūrimas dokumentas Nr
DocType: Issue,Issue,emisija
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11,Records,Įrašai
DocType: Asset,Scrapped,metalo laužą
DocType: Purchase Invoice,Returns,grąžinimas
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +42,WIP Warehouse,WIP sandėlis
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195,Serial No {0} is under maintenance contract upto {1},Serijos Nr {0} yra pagal priežiūros sutartį net iki {1}
apps/erpnext/erpnext/config/hr.py +35,Recruitment,verbavimas
DocType: Lead,Organization Name,Organizacijos pavadinimas
DocType: Tax Rule,Shipping State,Pristatymas valstybė
,Projected Quantity as Source,"Prognozuojama, Kiekis, kaip šaltinį"
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item must be added using 'Get Items from Purchase Receipts' button,Prekė turi būti pridėta naudojant &quot;gauti prekes nuo pirkimo kvitus&quot; mygtuką
DocType: Delivery Trip,Delivery Trip,Pristatymo kelionė
DocType: Student,A-,A-
DocType: Production Planning Tool,Include non-stock items,Įtraukti ne atsargos
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Sales Expenses,pardavimų sąnaudos
DocType: Consultation,Diagnosis,Diagnozė
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18,Standard Buying,Standartinė Ieško
DocType: GL Entry,Against,prieš
DocType: Item,Default Selling Cost Center,Numatytasis Parduodami Kaina centras
DocType: Sales Partner,Implementation Partner,įgyvendinimas partneriu
apps/erpnext/erpnext/accounts/page/pos/pos.js +1614,ZIP Code,Pašto kodas
apps/erpnext/erpnext/controllers/selling_controller.py +248,Sales Order {0} is {1},Pardavimų užsakymų {0} yra {1}
DocType: Opportunity,Contact Info,Kontaktinė informacija
apps/erpnext/erpnext/config/stock.py +315,Making Stock Entries,Padaryti atsargų papildymams
DocType: Packing Slip,Net Weight UOM,Grynasis svoris UOM
DocType: Item,Default Supplier,numatytasis Tiekėjas
DocType: Manufacturing Settings,Over Production Allowance Percentage,Per Gamybos pašalpų procentinė dalis
DocType: Employee Loan,Repayment Schedule,grąžinimo grafikas
DocType: Shipping Rule Condition,Shipping Rule Condition,Gamykliniai nustatymai taisyklė
DocType: Holiday List,Get Weekly Off Dates,Gauk Savaitinis Off Datos
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33,End Date can not be less than Start Date,Pabaigos data negali būti mažesnė negu pradžios data
DocType: Sales Person,Select company name first.,Pasirinkite įmonės pavadinimas pirmas.
apps/erpnext/erpnext/hub_node/page/hub/hub.js +181,Low to High,Nuo mažo iki aukšto
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +202,Email sent to {0},El. Laiškas išsiųstas {0}
apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,"Citatos, gautų iš tiekėjų."
apps/erpnext/erpnext/config/manufacturing.py +74,Replace BOM and update latest price in all BOMs,Pakeiskite BOM ir atnaujinkite naujausią kainą visose BOM
apps/erpnext/erpnext/controllers/selling_controller.py +27,To {0} | {1} {2},Norėdami {0} | {1} {2}
DocType: Delivery Trip,Driver Name,Vairuotojo vardas
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Vidutinis amžius
DocType: Education Settings,Attendance Freeze Date,Lankomumas nuo užšalimo data
DocType: Education Settings,Attendance Freeze Date,Lankomumas nuo užšalimo data
apps/erpnext/erpnext/utilities/user_progress.py +107,List a few of your suppliers. They could be organizations or individuals.,Sąrašas keletą savo tiekėjais. Jie gali būti organizacijos ar asmenys.
apps/erpnext/erpnext/templates/pages/home.html +31,View All Products,Peržiūrėti visus produktus
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Minimalus Švinas Amžius (dienomis)
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Minimalus Švinas Amžius (dienomis)
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +57,All BOMs,Visi BOMs
DocType: Patient,Default Currency,Pirminė kainoraščio valiuta
DocType: Expense Claim,From Employee,iš darbuotojo
DocType: Driver,Cellphone Number,Mobiliojo telefono numeris
apps/erpnext/erpnext/controllers/accounts_controller.py +471,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,"Įspėjimas: sistema netikrins per didelių sąskaitų, nes suma už prekę {0} iš {1} yra lygus nuliui"
DocType: Journal Entry,Make Difference Entry,Padaryti Skirtumas įrašą
DocType: Upload Attendance,Attendance From Date,Lankomumas Nuo data
DocType: Appraisal Template Goal,Key Performance Area,Pagrindiniai veiklos sritis
DocType: Program Enrollment,Transportation,Transportavimas
apps/erpnext/erpnext/controllers/item_variant.py +92,Invalid Attribute,Neteisingas Įgūdis
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +229,{0} {1} must be submitted,{0} {1} turi būti pateiktas
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +151,Quantity must be less than or equal to {0},Kiekis turi būti mažesnis arba lygus {0}
DocType: SMS Center,Total Characters,Iš viso Veikėjai
DocType: Employee Advance,Claimed,Pateikta pretenzija
DocType: Crop,Row Spacing,Eilučių tarpas
apps/erpnext/erpnext/controllers/buying_controller.py +164,Please select BOM in BOM field for Item {0},Prašome pasirinkti BOM BOM į lauką punkte {0}
DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-formos sąskaita faktūra detalės
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Mokėjimo Susitaikymas Sąskaita
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +42,Contribution %,indėlis%
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","Kaip už pirkimo parametrus, jei pirkimas įsakymu Reikalinga == &quot;Taip&quot;, tada sukurti sąskaitą-faktūrą, vartotojo pirmiausia reikia sukurti pirkinių užsakymą už prekę {0}"
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Įmonės registracijos numeriai jūsų nuoroda. Mokesčių numeriai ir kt
DocType: Sales Partner,Distributor,skirstytuvas
DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Krepšelis Pristatymas taisyklė
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252,Production Order {0} must be cancelled before cancelling this Sales Order,Gamybos Užsakyti {0} turi būti atšauktas prieš panaikinant šį pardavimo užsakymų
apps/erpnext/erpnext/public/js/controllers/transaction.js +71,Please set 'Apply Additional Discount On',Prašome nustatyti &quot;Taikyti papildomą nuolaidą On&quot;
,Ordered Items To Be Billed,Užsakytas prekes Norėdami būti mokami
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,From Range has to be less than To Range,Iš klasės turi būti mažesnis nei svyruoja
DocType: Global Defaults,Global Defaults,Global Numatytasis
apps/erpnext/erpnext/projects/doctype/project/project.py +226,Project Collaboration Invitation,Projektų Bendradarbiavimas Kvietimas
DocType: Salary Slip,Deductions,atskaitymai
DocType: Leave Allocation,LAL/,LAL /
DocType: Setup Progress Action,Action Name,Veiksmo pavadinimas
apps/erpnext/erpnext/public/js/financial_statements.js +75,Start Year,pradžios metus
apps/erpnext/erpnext/regional/india/utils.py +25,First 2 digits of GSTIN should match with State number {0},Pirmieji 2 skaitmenys GSTIN turi sutapti su Valstybinio numerio {0}
DocType: Purchase Invoice,Start date of current invoice's period,Pradžios data einamųjų sąskaitos faktūros laikotarpį
DocType: Salary Slip,Leave Without Pay,Palikite be darbo užmokesčio
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +366,Capacity Planning Error,Talpa planavimas Klaida
,Trial Balance for Party,Bandomoji likutis partijos
DocType: Lead,Consultant,konsultantas
DocType: Salary Slip,Earnings,Pajamos
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +421,Finished Item {0} must be entered for Manufacture type entry,Baigė punktas {0} reikia įvesti Gamyba tipo įrašas
apps/erpnext/erpnext/config/learn.py +87,Opening Accounting Balance,Atidarymo Apskaitos balansas
,GST Sales Register,"Paaiškėjo, kad GST Pardavimų Registruotis"
DocType: Sales Invoice Advance,Sales Invoice Advance,Pardavimų sąskaita faktūra Išankstinis
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +552,Nothing to request,Nieko prašyti
apps/erpnext/erpnext/public/js/setup_wizard.js +18,Select your Domains,Pasirinkite savo domenus
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34,Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3},Kitas Biudžeto įrašas &#39;{0} &quot;jau egzistuoja nuo {1} {2}&quot; fiskalinio metų {3}
DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Laukai bus kopijuojami tik kūrimo metu.
apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Actual Start Date' can not be greater than 'Actual End Date',&quot;Tikrasis pradžios data&quot; gali būti ne didesnis nei faktinio End Date &quot;
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117,Management,valdymas
DocType: Cheque Print Template,Payer Settings,mokėtojo Nustatymai
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""","Tai bus pridėtas prie elemento kodekso variante. Pavyzdžiui, jei jūsų santrumpa yra &quot;S.&quot;, o prekės kodas yra T-shirt &quot;, elementas kodas variantas bus&quot; T-shirt-SM &quot;"
DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,"Neto darbo užmokestis (žodžiais) bus matomas, kai jums sutaupyti darbo užmokestį."
DocType: Purchase Invoice,Is Return,Ar Grįžti
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +88,Caution,Atsargiai
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +813,Return / Debit Note,Prekių grąžinimas / debeto aviza
DocType: Price List Country,Price List Country,Kainų sąrašas Šalis
DocType: Item,UOMs,UOMs
apps/erpnext/erpnext/stock/utils.py +209,{0} valid serial nos for Item {1},{0} galioja eilės numeriai už prekę {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,Prekės kodas negali būti keičiamas Serial No.
DocType: Purchase Invoice Item,UOM Conversion Factor,UOM konversijos faktorius
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40,Please enter Item Code to get Batch Number,Prašome įvesti Prekės kodas gauti SERIJOS NUMERIS
DocType: Stock Settings,Default Item Group,Numatytasis Elementas Grupė
DocType: Employee Loan,Partially Disbursed,dalinai Išmokėta
apps/erpnext/erpnext/config/non_profit.py +73,Grant information.,Informacija apie dotaciją.
apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Tiekėjas duomenų bazę.
DocType: Account,Balance Sheet,Balanso lapas
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +748,Cost Center For Item with Item Code ',Kainuos centras už prekę su Prekės kodas &quot;
DocType: Fee Validity,Valid Till,Galioja iki
apps/erpnext/erpnext/accounts/page/pos/pos.js +2474,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Mokėjimo būdas yra neužpildė. Prašome patikrinti, ar sąskaita buvo nustatytas mokėjimų Mode arba POS profilis."
apps/erpnext/erpnext/buying/utils.py +74,Same item cannot be entered multiple times.,Tas pats daiktas negali būti įrašytas kelis kartus.
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","Daugiau sąskaitos gali būti grupėse, tačiau įrašai gali būti pareikštas ne grupės"
DocType: Lead,Lead,Vadovauti
DocType: Email Digest,Payables,Mokėtinos sumos
DocType: Course,Course Intro,Žinoma Įvadas
apps/erpnext/erpnext/stock/doctype/batch/batch.js +97,Stock Entry {0} created,"Atsargų, {0} sukūrė"
apps/erpnext/erpnext/controllers/buying_controller.py +316,Row #{0}: Rejected Qty can not be entered in Purchase Return,Eilutės # {0}: Atmesta Kiekis negali būti įrašytas į pirkimo Grįžti
,Purchase Order Items To Be Billed,Pirkimui užsakyti klausimai turi būti apmokestinama
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +45,Updating estimated arrival times.,Atnaujintas numatomas atvykimo laikas.
DocType: Program Enrollment Tool,Enrollment Details,Registracijos duomenys
DocType: Purchase Invoice Item,Net Rate,grynasis Balsuok
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +147,Please select a customer,Pasirinkite klientą
DocType: Purchase Invoice Item,Purchase Invoice Item,Pirkimo faktūros Elementą
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,Akcijų Ledgeris Įrašai ir GL Įrašai pakartotinai paskelbtas kur nors pasirinktų įsigijimo kvitai
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,1 punktas
DocType: Holiday,Holiday,atostogų
DocType: Support Settings,Close Issue After Days,Uždaryti išdavimas Po dienos
DocType: Leave Control Panel,Leave blank if considered for all branches,"Palikite tuščią, jei laikomas visų šakų"
DocType: Bank Guarantee,Validity in Days,Galiojimas dienomis
DocType: Bank Guarantee,Validity in Days,Galiojimas dienomis
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21,C-form is not applicable for Invoice: {0},C-formos netaikoma Sąskaita: {0}
DocType: Payment Reconciliation,Unreconciled Payment Details,Unreconciled Mokėjimo informacija
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Užsakyti Grafas
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Užsakyti Grafas
DocType: Global Defaults,Current Fiscal Year,Einamuosius fiskalinius metus
DocType: Purchase Order,Group same items,Grupė pačių daiktų
DocType: Purchase Invoice,Disable Rounded Total,Išjungti Apvalus Iš viso
DocType: Employee Loan Application,Repayment Info,grąžinimas Informacija
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +446,'Entries' cannot be empty,&quot;Įrašai&quot; negali būti tuščias
DocType: Maintenance Team Member,Maintenance Role,Priežiūros vaidmuo
apps/erpnext/erpnext/utilities/transaction_base.py +86,Duplicate row {0} with same {1},Dubliuoti eilutė {0} su tuo pačiu {1}
,Trial Balance,bandomasis balansas
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +438,Fiscal Year {0} not found,Finansiniai metai {0} nerastas
apps/erpnext/erpnext/config/hr.py +305,Setting up Employees,Įsteigti Darbuotojai
DocType: Sales Order,SO-,SO
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +153,Please select prefix first,Prašome pasirinkti prefiksą pirmas
DocType: Student,O-,O-
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189,Research,tyrimas
DocType: Maintenance Visit Purpose,Work Done,Darbas pabaigtas
apps/erpnext/erpnext/controllers/item_variant.py +33,Please specify at least one attribute in the Attributes table,Prašome nurodyti bent vieną atributą Atributų lentelės
DocType: Announcement,All Students,Visi studentai
apps/erpnext/erpnext/assets/doctype/asset/asset.py +45,Item {0} must be a non-stock item,Prekė {0} turi būti ne akcijų punktas
apps/erpnext/erpnext/stock/doctype/batch/batch.js +18,View Ledger,Peržiūrėti Ledgeris
DocType: Grading Scale,Intervals,intervalai
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Seniausi
apps/erpnext/erpnext/stock/doctype/item/item.py +500,"An Item Group exists with same name, please change the item name or rename the item group","Prekę grupė egzistuoja to paties pavadinimo, prašom pakeisti elementą vardą ar pervardyti elementą grupę"
DocType: Crop Cycle,Less than a year,Mažiau nei metus
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Studentų Mobilus Ne
apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105,Rest Of The World,Likęs pasaulis
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,Naudodami {0} punktas negali turėti Serija
DocType: Crop,Yield UOM,Išeiga UOM
,Budget Variance Report,Biudžeto Dispersija ataskaita
DocType: Salary Slip,Gross Pay,Pilna Mokėti
DocType: Item,Is Item from Hub,Ar prekė iš centro
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118,Row {0}: Activity Type is mandatory.,Eilutės {0}: veiklos rūšis yra privalomas.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166,Dividends Paid,Dividendai
apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36,Accounting Ledger,apskaitos Ledgeris
DocType: Stock Reconciliation,Difference Amount,skirtumas suma
DocType: Purchase Invoice,Reverse Charge,Atvirkštinio apmokestinimo
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172,Retained Earnings,Nepaskirstytasis pelnas
DocType: Vehicle Log,Service Detail,Paslaugų detalės
DocType: BOM,Item Description,Prekės Aprašymas
DocType: Student Sibling,Student Sibling,Studentų giminystės
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +18,Payment Mode,Mokėjimo būdas
DocType: Purchase Invoice,Supplied Items,"prekių tiekimu,"
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85,Please set an active menu for Restaurant {0},Nustatykite aktyvų Restorano {0} meniu
DocType: Student,STUD.,Stud.
DocType: Production Order,Qty To Manufacture,Kiekis gaminti
DocType: Email Digest,New Income,nauja pajamos
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Išlaikyti tą patį tarifą visoje pirkimo ciklo
DocType: Opportunity Item,Opportunity Item,galimybė punktas
,Student and Guardian Contact Details,Studentų ir globėjas Kontaktinė informacija
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +51,Row {0}: For supplier {0} Email Address is required to send email,Eilutės {0}: Dėl tiekėjo {0} el.pašto adresas yra reikalingi siųsti laišką
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72,Temporary Opening,laikinas atidarymas
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +10,View Hub,Peržiūrėti centru
,Employee Leave Balance,Darbuotojų atostogos balansas
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147,Balance for Account {0} must always be {1},Likutis sąskaitoje {0} visada turi būti {1}
DocType: Patient Appointment,More Info,Daugiau informacijos
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +180,Valuation Rate required for Item in row {0},"Vertinimo tarifas, kurio reikia už prekę iš eilės {0}"
DocType: Supplier Scorecard,Scorecard Actions,Rezultatų kortelės veiksmai
apps/erpnext/erpnext/utilities/user_progress.py +166,Example: Masters in Computer Science,Pavyzdys: magistro Computer Science
DocType: Purchase Invoice,Rejected Warehouse,atmesta sandėlis
DocType: GL Entry,Against Voucher,prieš kupono
DocType: Item,Default Buying Cost Center,Numatytasis Ieško kaina centras
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.","Norėdami gauti geriausią iš ERPNext, mes rekomenduojame, kad jūs šiek tiek laiko ir žiūrėti šiuos pagalbos video."
apps/erpnext/erpnext/accounts/page/pos/pos.js +76, to ,į
DocType: Supplier Quotation Item,Lead Time in days,Švinas Laikas dienų
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +58,Accounts Payable Summary,Mokėtinos sumos Santrauka
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +321,Payment of salary from {0} to {1},Apmokėjimas algos nuo {0} ir {1}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213,Not authorized to edit frozen Account {0},Neregistruota redaguoti įšaldytą sąskaitą {0}
DocType: Journal Entry,Get Outstanding Invoices,Gauk neapmokėtų sąskaitų faktūrų
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +84,Sales Order {0} is not valid,Pardavimų užsakymų {0} negalioja
DocType: Supplier Scorecard,Warn for new Request for Quotations,Įspėti apie naują prašymą dėl pasiūlymų
apps/erpnext/erpnext/utilities/activation.py +91,Purchase orders help you plan and follow up on your purchases,Pirkimo pavedimai padės jums planuoti ir sekti savo pirkimų
apps/erpnext/erpnext/setup/doctype/company/company.py +228,"Sorry, companies cannot be merged","Atsiprašome, įmonės negali būti sujungtos"
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151,Lab Test Prescriptions,Lab testo rekvizitai
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +162,"The total Issue / Transfer quantity {0} in Material Request {1}  \
							cannot be greater than requested quantity {2} for Item {3}",Bendras išdavimas / Pervežimas kiekis {0} Krovimas Užsisakyti {1} \ negali būti didesnis nei prašomo kiekio {2} už prekę {3}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197,Small,mažas
DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Sąskaitų faktūrų kūrimo įrankio atidarymas
DocType: Education Settings,Employee Number,Darbuotojo numeris
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67,Case No(s) already in use. Try from Case No {0},Byloje Nr (-ai) jau naudojamas. Pabandykite iš byloje Nr {0}
DocType: Project,% Completed,% Baigtas
,Invoiced Amount (Exculsive Tax),Sąskaitoje suma (Exculsive Mokesčių)
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14,Item 2,2 punktas
DocType: Supplier,SUPP-,maitinimo iš tinklo laidas
DocType: Training Event,Training Event,Kvalifikacijos tobulinimo renginys
DocType: Item,Auto re-order,Auto naujo užsakymas
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,Iš viso Pasiektas
DocType: Employee,Place of Issue,Išdavimo vieta
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101,Contract,sutartis
DocType: Plant Analysis,Laboratory Testing Datetime,Laboratorijos bandymo data laikas
DocType: Email Digest,Add Quote,Pridėti Citata
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +965,UOM coversion factor required for UOM: {0} in Item: {1},UOM coversion faktorius reikalingas UOM: {0} prekės: {1}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92,Indirect Expenses,netiesioginės išlaidos
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +93,Row {0}: Qty is mandatory,Eilutės {0}: Kiekis yra privalomi
DocType: Agriculture Analysis Criteria,Agriculture,Žemdirbystė
apps/erpnext/erpnext/accounts/page/pos/pos.js +786,Sync Master Data,Sinchronizavimo Master Data
DocType: Asset Repair,Repair Cost,Remonto kaina
apps/erpnext/erpnext/utilities/user_progress.py +135,Your Products or Services,Savo produktus ar paslaugas
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15,Failed to login,Nepavyko prisijungti
DocType: Special Test Items,Special Test Items,Specialūs testo elementai
DocType: Mode of Payment,Mode of Payment,mokėjimo būdas
apps/erpnext/erpnext/stock/doctype/item/item.py +192,Website Image should be a public file or website URL,Interneto svetainė Paveikslėlis turėtų būti valstybės failą ar svetainės URL
DocType: Student Applicant,AP,A.
DocType: Purchase Invoice Item,BOM,BOM
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37,This is a root item group and cannot be edited.,Tai yra šaknis punktas grupė ir negali būti pakeisti.
DocType: Journal Entry Account,Purchase Order,Pirkimo užsakymas
DocType: Vehicle,Fuel UOM,kuro UOM
DocType: Warehouse,Warehouse Contact Info,Sandėlių Kontaktinė informacija
DocType: Payment Entry,Write Off Difference Amount,Nurašyti skirtumo suma
DocType: Volunteer,Volunteer Name,Savanorio vardas
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +434,"{0}: Employee email not found, hence email not sent","{0}: Darbuotojų elektroninio pašto nerastas, todėl elektroninių laiškų, nesiunčiamas"
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85,Shipping rule not applicable for country {0},Pristatymo taisyklė netaikoma šaliai {0}
DocType: Item,Foreign Trade Details,Užsienio prekybos informacija
,Assessment Plan Status,Vertinimo plano būsena
DocType: Email Digest,Annual Income,Metinės pajamos
DocType: Serial No,Serial No Details,Serijos Nr detalės
DocType: Purchase Invoice Item,Item Tax Rate,Prekė Mokesčio tarifas
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +75,Please select Physician and Date,Pasirinkite gydytoją ir datą
DocType: Student Group Student,Group Roll Number,Grupė salė Taškų
DocType: Student Group Student,Group Roll Number,Grupė salė Taškų
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +143,"For {0}, only credit accounts can be linked against another debit entry",Dėl {0} tik kredito sąskaitos gali būti susijęs su kitos debeto įrašą
apps/erpnext/erpnext/projects/doctype/project/project.py +80,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,Bendras visų užduočių svoriai turėtų būti 1. Prašome reguliuoti svareliai visų projekto užduotis atitinkamai
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +575,Delivery Note {0} is not submitted,Važtaraštis {0} nebus pateiktas
apps/erpnext/erpnext/stock/get_item_details.py +146,Item {0} must be a Sub-contracted Item,Prekė {0} turi būti Prekė pagal subrangos sutartis
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43,Capital Equipments,kapitalo įranga
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.","Kainodaros taisyklė pirmiausia atrenkami remiantis &quot;Taikyti&quot; srityje, kuris gali būti punktas, punktas Grupė ar prekės ženklą."
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +246,Please set the Item Code first,Pirmiausia nustatykite elemento kodą
DocType: Item,ITEM-,item-
apps/erpnext/erpnext/controllers/selling_controller.py +122,Total allocated percentage for sales team should be 100,Iš viso skyrė procentas pardavimų vadybininkas turi būti 100
DocType: Sales Invoice Item,Edit Description,Redaguoti Aprašymas
DocType: Antibiotic,Antibiotic,Antibiotikas
,Team Updates,komanda Atnaujinimai
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +910,For Supplier,tiekėjas
DocType: Account,Setting Account Type helps in selecting this Account in transactions.,"Nustatymas sąskaitos rūšis, padedanti renkantis šį Narystė sandoriuose."
DocType: Purchase Invoice,Grand Total (Company Currency),Bendra suma (Įmonės valiuta)
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Create Print Format,Sukurti Spausdinti formatas
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Sukurtas mokestis
apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},"Neradote bet kurį elementą, vadinamą {0}"
DocType: Supplier Scorecard Criteria,Criteria Formula,Kriterijų formulė
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,Iš viso Siunčiami
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""",Gali būti tik vienas Pristatymas taisyklė Būklė 0 arba tuščią vertės &quot;vertė&quot;
DocType: Authorization Rule,Transaction,sandoris
DocType: Patient Appointment,Duration,Trukmė
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Pastaba: Ši kaina centras yra grupė. Negali padaryti apskaitos įrašus pagal grupes.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +54,Child warehouse exists for this warehouse. You can not delete this warehouse.,Vaikų sandėlis egzistuoja šiame sandėlyje. Jūs negalite trinti šį sandėlį.
DocType: Item,Website Item Groups,Interneto svetainė punktas Grupės
DocType: Purchase Invoice,Total (Company Currency),Iš viso (Įmonės valiuta)
apps/erpnext/erpnext/stock/utils.py +204,Serial number {0} entered more than once,Serijos numeris {0} įvesta daugiau nei vieną kartą
DocType: Journal Entry,Journal Entry,žurnalo įrašą
DocType: Expense Claim Advance,Unclaimed amount,Neprašyta suma
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +148,{0} items in progress,{0} elementų pažangą
DocType: Workstation,Workstation Name,Kompiuterizuotos darbo vietos Vardas
DocType: Grading Scale Interval,Grade Code,Įvertinimas kodas
DocType: POS Item Group,POS Item Group,POS punktas grupė
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,Siųskite Digest:
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +591,BOM {0} does not belong to Item {1},BOM {0} nepriklauso punkte {1}
DocType: Sales Partner,Target Distribution,Tikslinė pasiskirstymas
DocType: Salary Slip,Bank Account No.,Banko sąskaitos Nr
DocType: Naming Series,This is the number of the last created transaction with this prefix,Tai yra paskutinio sukurto skaičius operacijoje su šio prefikso
DocType: Supplier Scorecard,"Scorecard variables can be used, as well as:
{total_score} (the total score from that period),
{period_number} (the number of periods to present day)
","Galima naudoti rodiklių kortelių kintamieji, taip pat: {total_score} (bendras rezultatas iš šio laikotarpio), {period_number} (laikotarpių skaičius iki dabartinės dienos)"
DocType: Quality Inspection Reading,Reading 8,Skaitymas 8
DocType: Sales Partner,Agent,agentas
DocType: Purchase Invoice,Taxes and Charges Calculation,Mokesčiai ir rinkliavos apskaičiavimas
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Užsakyti Turto nusidėvėjimas Įėjimas Automatiškai
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Užsakyti Turto nusidėvėjimas Įėjimas Automatiškai
DocType: BOM Operation,Workstation,Kompiuterizuotos darbo vietos
DocType: Request for Quotation Supplier,Request for Quotation Supplier,Užklausimas Tiekėjo
DocType: Healthcare Settings,Registration Message,Registracijos pranešimas
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154,Hardware,techninė įranga
DocType: Prescription Dosage,Prescription Dosage,Receptinis dozavimas
DocType: Attendance,HR Manager,Žmogiškųjų išteklių vadybininkas
apps/erpnext/erpnext/accounts/party.py +178,Please select a Company,"Prašome pasirinkti įmonę,"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92,Privilege Leave,privilegija atostogos
DocType: Purchase Invoice,Supplier Invoice Date,Tiekėjas sąskaitos faktūros išrašymo data
apps/erpnext/erpnext/templates/includes/product_page.js +18,per,už
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90,You need to enable Shopping Cart,Jums reikia įgalinti Prekių krepšelis
DocType: Payment Entry,Writeoff,Nusirašinėti
DocType: Stock Settings,Naming Series Prefix,Vardų serijos prefiksas
DocType: Appraisal Template Goal,Appraisal Template Goal,Vertinimas Šablonas tikslas
DocType: Salary Component,Earning,Pelningiausi
DocType: Supplier Scorecard,Scoring Criteria,Balų kriterijai
DocType: Purchase Invoice,Party Account Currency,Šalis paskyra Valiuta
,BOM Browser,BOM naršyklė
apps/erpnext/erpnext/templates/emails/training_event.html +13,Please update your status for this training event,Prašome atnaujinti savo statusą šiam renginiui
DocType: Purchase Taxes and Charges,Add or Deduct,Pridėti arba atimama
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148,Overlapping conditions found between:,rasti tarp sutampančių sąlygos:
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187,Against Journal Entry {0} is already adjusted against some other voucher,Prieš leidinyje Įėjimo {0} jau koreguojama kitu kuponą
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68,Total Order Value,Iš viso užsakymo vertė
apps/erpnext/erpnext/demo/setup/setup_data.py +328,Food,maistas
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +51,Ageing Range 3,Senėjimas klasės 3
DocType: Maintenance Schedule Item,No of Visits,Nėra apsilankymų
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165,Maintenance Schedule {0} exists against {1},Techninės priežiūros grafikas {0} egzistuoja nuo {1}
apps/erpnext/erpnext/hub_node/page/hub/hub.js +118,Do you want to publish your Items to Hub ?,Ar norite paskelbti savo elementus į centrą?
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36,Enrolling student,mokosi studentas
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,Currency of the Closing Account must be {0},Valiuta uždarymo sąskaita turi būti {0}
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Suma kiekis visų tikslų turėtų būti 100. Tai {0}
DocType: Project,Start and End Dates,Pradžios ir pabaigos datos
,Delivered Items To Be Billed,Pristatyto objekto Norėdami būti mokami
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16,Open BOM {0},Atviras BOM {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60,Warehouse cannot be changed for Serial No.,Sandėlių negali būti keičiama Serijos Nr
DocType: Authorization Rule,Average Discount,Vidutinis nuolaida
DocType: Purchase Invoice Item,UOM,UOM
DocType: Rename Tool,Utilities,Komunalinės paslaugos
DocType: POS Profile,Accounting,apskaita
DocType: Employee,EMP/,EMP /
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133,Please select batches for batched item ,Prašome pasirinkti partijas partijomis prekę
DocType: Asset,Depreciation Schedules,nusidėvėjimo Tvarkaraščiai
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +159,Following accounts might be selected in GST Settings:,GST nustatymuose gali būti parinktos šios paskyros:
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +89,Application period cannot be outside leave allocation period,Taikymo laikotarpis negali būti ne atostogos paskirstymo laikotarpis
DocType: Activity Cost,Projects,projektai
DocType: Payment Request,Transaction Currency,Operacijos valiuta
apps/erpnext/erpnext/controllers/buying_controller.py +30,From {0} | {1} {2},Iš {0} | {1} {2}
DocType: Production Order Operation,Operation Description,Veikimo aprašymas
DocType: Item,Will also apply to variants,Taip pat bus taikoma variantų
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.,"Nepavyksta pakeisti finansiniai metai pradžios data ir fiskalinių metų pabaigos, kai finansiniai metai yra išsaugotas."
DocType: Quotation,Shopping Cart,Prekių krepšelis
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Vid Dienos Siunčiami
DocType: POS Profile,Campaign,Kampanija
DocType: Supplier,Name and Type,Pavadinimas ir tipas
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +66,Approval Status must be 'Approved' or 'Rejected',Patvirtinimo būsena turi būti &quot;Patvirtinta&quot; arba &quot;Atmesta&quot;
DocType: Physician,Contacts and Address,Kontaktai ir adresas
DocType: Purchase Invoice,Contact Person,kontaktinis asmuo
apps/erpnext/erpnext/projects/doctype/task/task.py +38,'Expected Start Date' can not be greater than 'Expected End Date',&quot;Tikėtinas pradžios data&quot; gali būti ne didesnis nei &quot;Expected Pabaigos data&quot;
DocType: Course Scheduling Tool,Course End Date,Žinoma Pabaigos data
DocType: Holiday List,Holidays,šventės
DocType: Sales Order Item,Planned Quantity,planuojamas kiekis
DocType: Purchase Invoice Item,Item Tax Amount,Prekė Mokesčių suma
DocType: Water Analysis,Water Analysis Criteria,Vandens analizės kriterijai
DocType: Item,Maintain Stock,išlaikyti Stock
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +222,Stock Entries already created for Production Order ,Akcijų įrašai jau sukurtos gamybos ordino
DocType: Employee,Prefered Email,Pageidaujamas paštas
DocType: Student Admission,Eligibility and Details,Tinkamumas ir detalės
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +33,Net Change in Fixed Asset,Grynasis pokytis ilgalaikio turto
DocType: Leave Control Panel,Leave blank if considered for all designations,"Palikite tuščią, jei laikomas visų pavadinimų"
apps/erpnext/erpnext/controllers/accounts_controller.py +799,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Mokesčio tipas &quot;Tikrasis&quot; iš eilės {0} negali būti įtraukti į klausimus lygis
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +382,Max: {0},Max: {0}
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,nuo datetime
DocType: Email Digest,For Company,dėl Company
apps/erpnext/erpnext/config/support.py +17,Communication log.,Ryšio žurnalas.
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +193,"Request for Quotation is disabled to access from portal, for more check portal settings.","Užklausimas yra išjungtas patekti iš portalo, daugiau patikrinimų portalo nustatymus."
DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Tiekėjo rezultatų lentelės vertinimo kintamasis
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Buying Amount,Ieško suma
DocType: Sales Invoice,Shipping Address Name,Pristatymas Adresas Pavadinimas
DocType: Material Request,Terms and Conditions Content,Terminai ir sąlygos turinys
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18,There were errors creating Course Schedule,Kuriant tvarkaraštį sukūrėme klaidų
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +580,cannot be greater than 100,negali būti didesnis nei 100
apps/erpnext/erpnext/stock/doctype/item/item.py +720,Item {0} is not a stock Item,Prekė {0} nėra sandėlyje punktas
DocType: Maintenance Visit,Unscheduled,Neplanuotai
DocType: Employee,Owned,priklauso
DocType: Salary Detail,Depends on Leave Without Pay,Priklauso nuo atostogų be Pay
DocType: Pricing Rule,"Higher the number, higher the priority","Kuo didesnis skaičius, didesnis prioritetas"
,Purchase Invoice Trends,Pirkimo faktūros tendencijos
DocType: Employee,Better Prospects,Geresnės perspektyvos
apps/erpnext/erpnext/stock/doctype/batch/batch.py +139,"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","Eilutė # {0}: Partija {1} turi tik {2} vnt. Prašome pasirinkti kitą partiją, kuri turi gauti {3} Kiekis arba padalinti eilutę į kelias eilutes, pristatyti / problemą iš kelių partijų"
DocType: Vehicle,License Plate,Valstybinis numeris
DocType: Appraisal,Goals,Tikslai
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +343,Select POS Profile,Pasirinkite POS profilį
DocType: Warranty Claim,Warranty / AMC Status,Garantija / AMC Būsena
,Accounts Browser,sąskaitos naršyklė
DocType: Payment Entry Reference,Payment Entry Reference,Mokėjimo Įėjimo Nuoroda
DocType: GL Entry,GL Entry,GL įrašas
DocType: HR Settings,Employee Settings,darbuotojų Nustatymai
,Batch-Wise Balance History,Serija-Išminčius Balansas istorija
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73,Print settings updated in respective print format,Spausdinimo parametrai atnaujinama atitinkamos spausdinimo formatą
DocType: Package Code,Package Code,Pakuotės kodas
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105,Apprentice,mokinys
DocType: Purchase Invoice,Company GSTIN,Įmonės GSTIN
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +105,Negative Quantity is not allowed,Neigiama Kiekis neleidžiama
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges",Mokesčių detalė stalo nerealu iš punkto meistras kaip eilutę ir saugomi šioje srityje. Naudojama mokesčių ir rinkliavų
DocType: Supplier Scorecard Period,SSC-,SSC-
apps/erpnext/erpnext/hr/doctype/employee/employee.py +159,Employee cannot report to himself.,Darbuotojas negali pranešti pats.
DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Jei sąskaita yra sušaldyti, įrašai leidžiama ribojamų vartotojams."
DocType: Email Digest,Bank Balance,banko balansas
apps/erpnext/erpnext/accounts/party.py +243,Accounting Entry for {0}: {1} can only be made in currency: {2},Apskaitos įrašas už {0}: {1} galima tik valiuta: {2}
DocType: Job Opening,"Job profile, qualifications required etc.","Darbo profilis, reikalingas kvalifikacijos ir tt"
DocType: Journal Entry Account,Account Balance,Sąskaitos balansas
apps/erpnext/erpnext/config/accounts.py +183,Tax Rule for transactions.,Mokesčių taisyklė sandorius.
DocType: Rename Tool,Type of document to rename.,Dokumento tipas pervadinti.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},{0} {1}: Klientas privalo prieš gautinos sąskaitos {2}
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Iš viso mokesčiai ir rinkliavos (Įmonės valiuta)
apps/erpnext/erpnext/config/healthcare.py +154,Lab Test Template.,Laboratorijos bandymo šablonas.
DocType: Weather,Weather Parameter,Oras parametras
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60,Show unclosed fiscal year's P&L balances,Rodyti Atvirų fiskalinius metus anketa P &amp; L likučius
DocType: Lab Test Template,Collection Details,Kolekcijos duomenys
DocType: POS Profile,Allow Print Before Pay,Leisti spausdinti prieš apmokėjimą
DocType: Land Unit,Linked Soil Texture,Susijusi dirvožemio tekstūra
DocType: Shipping Rule,Shipping Account,Pristatymas paskyra
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92,{0} {1}: Account {2} is inactive,{0} {1}: Sąskaitos {2} yra neaktyvus
apps/erpnext/erpnext/utilities/activation.py +82,Make Sales Orders to help you plan your work and deliver on-time,"Padaryti pardavimo užsakymus, siekiant padėti jums planuoti savo darbą ir įgyvendinti laiku"
DocType: Quality Inspection,Readings,Skaitiniai
DocType: Stock Entry,Total Additional Costs,Iš viso papildomų išlaidų
DocType: Course Schedule,SH,SH
DocType: BOM,Scrap Material Cost(Company Currency),Laužas Medžiaga Kaina (Įmonės valiuta)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66,Sub Assemblies,sub Agregatai
DocType: Asset,Asset Name,"turto pavadinimas,"
DocType: Project,Task Weight,užduotis Svoris
DocType: Shipping Rule Condition,To Value,Vertinti
DocType: Asset Movement,Stock Manager,akcijų direktorius
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +154,Source warehouse is mandatory for row {0},Šaltinis sandėlis yra privalomas eilės {0}
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38,The Payment Term at row {0} is possibly a duplicate.,Apmokėjimo terminas eilutėje {0} yra galimas dublikatas.
apps/erpnext/erpnext/public/js/setup_wizard.js +30,Agriculture (beta),Žemės ūkis (beta)
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +856,Packing Slip,Pakavimo lapelis
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Office Rent,Biuro nuoma
apps/erpnext/erpnext/config/setup.py +111,Setup SMS gateway settings,Sąranka SMS Gateway nustatymai
DocType: Disease,Common Name,Dažnas vardas
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61,Import Failed!,Importas Nepavyko!
apps/erpnext/erpnext/public/js/templates/address_list.html +20,No address added yet.,Nėra adresas pridėta dar.
DocType: Workstation Working Hour,Workstation Working Hour,Kompiuterizuotos darbo vietos Darbo valandos
DocType: Vital Signs,Blood Pressure,Kraujo spaudimas
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125,Analyst,analitikas
DocType: Item,Inventory,inventorius
DocType: Item,Sales Details,pardavimų detalės
DocType: Quality Inspection,QI-,QI-
DocType: Opportunity,With Items,su daiktais
DocType: Asset Maintenance,Maintenance Team,Techninės priežiūros komanda
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,Be Kiekis
DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Patvirtinti mokosi kursai studentams Studentų grupės
DocType: Notification Control,Expense Claim Rejected,Kompensuojamos teiginys atmetamas
DocType: Item,Item Attribute,Prekė Įgūdis
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147,Government,vyriausybė
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40,Expense Claim {0} already exists for the Vehicle Log,"Kompensuojamos Pretenzija {0} jau egzistuoja, kad transporto priemonė Prisijungti"
apps/erpnext/erpnext/public/js/setup_wizard.js +64,Institute Name,institutas Vardas
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117,Please enter repayment Amount,Prašome įvesti grąžinimo suma
apps/erpnext/erpnext/config/stock.py +305,Item Variants,Prekė Variantai
apps/erpnext/erpnext/public/js/setup_wizard.js +29,Services,Paslaugos
DocType: HR Settings,Email Salary Slip to Employee,Siųsti darbo užmokestį į darbuotojų
DocType: Cost Center,Parent Cost Center,Tėvų Kaina centras
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1039,Select Possible Supplier,Pasirinkite Galima Tiekėjo
DocType: Sales Invoice,Source,šaltinis
apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Rodyti uždarytas
DocType: Leave Type,Is Leave Without Pay,Ar palikti be Pay
apps/erpnext/erpnext/stock/doctype/item/item.py +250,Asset Category is mandatory for Fixed Asset item,Turto Kategorija privaloma ilgalaikio turto
DocType: Fee Validity,Fee Validity,Mokesčio galiojimas
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +145,No records found in the Payment table,rasti Mokėjimo stalo Nėra įrašų
apps/erpnext/erpnext/education/utils.py +19,This {0} conflicts with {1} for {2} {3},Šis {0} prieštarauja {1} ir {2} {3}
DocType: Student Attendance Tool,Students HTML,studentai HTML
DocType: POS Profile,Apply Discount,taikyti nuolaidą
DocType: GST HSN Code,GST HSN Code,"Paaiškėjo, kad GST HSN kodas"
DocType: Employee External Work History,Total Experience,Iš viso Patirtis
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70,Open Projects,Atviri projektai
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +286,Packing Slip(s) cancelled,Pakavimo Kuponas (-ai) atšauktas
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +31,Cash Flow from Investing,Pinigų srautai iš investicinės
DocType: Program Course,Program Course,programos kursas
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,Freight and Forwarding Charges,Krovinių ir ekspedijavimo Mokesčiai
DocType: Homepage,Company Tagline for website homepage,Įmonės Paantraštė interneto svetainės pagrindiniame puslapyje
DocType: Item Group,Item Group Name,Prekė Grupės pavadinimas
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Taken,Paimta
DocType: Student,Date of Leaving,Data Palikus
DocType: Pricing Rule,For Price List,Kaina sąrašas
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27,Executive Search,Executive Search
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55,Setting defaults,Numatytasis nustatymas
apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,Sukurti leads
DocType: Maintenance Schedule,Schedules,tvarkaraščiai
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +458,POS Profile is required to use Point-of-Sale,"Pozicijos profilis reikalingas, norint naudoti &quot;Point-of-Sale&quot;"
DocType: Purchase Invoice Item,Net Amount,Grynoji suma
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +138,{0} {1} has not been submitted so the action cannot be completed,{0} {1} nebuvo pateikta ir todėl veiksmai negali būti užbaigtas
DocType: Purchase Order Item Supplied,BOM Detail No,BOM Išsamiau Nėra
DocType: Landed Cost Voucher,Additional Charges,Papildomi mokesčiai
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Papildoma nuolaida Suma (Įmonės valiuta)
DocType: Supplier Scorecard,Supplier Scorecard,Tiekėjo rezultatų kortelė
DocType: Plant Analysis,Result Datetime,Rezultatas Datetime
apps/erpnext/erpnext/accounts/doctype/account/account.js +21,Please create new account from Chart of Accounts.,Prašome sukurti naują sąskaitą iš sąskaitų plano.
,Support Hour Distribution,Paramos valandos platinimas
DocType: Maintenance Visit,Maintenance Visit,priežiūra Aplankyti
DocType: Student,Leaving Certificate Number,Palikus Sertifikato numeris
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +63,"Appointment cancelled, Please review and cancel the invoice {0}",Paskyrimas atšauktas. Peržiūrėkite ir atšaukite sąskaitą {0}
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Turimas Serija Kiekis į sandėlį
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Update Print Format,Atnaujinti Spausdinti Formatas
DocType: Landed Cost Voucher,Landed Cost Help,Nusileido kaina Pagalba
DocType: Purchase Invoice,Select Shipping Address,Pasirinkite pristatymo adresas
apps/erpnext/erpnext/config/non_profit.py +28,Memebership Details,Savivaldybės duomenys
DocType: Leave Block List,Block Holidays on important days.,Blokuoti Šventės svarbiais dienų.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +71,Accounts Receivable Summary,Gautinos Santrauka
DocType: Employee Loan,Monthly Repayment Amount,Mėnesio grąžinimo suma
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9,Opening Invoices,Sąskaitų atidarymas
apps/erpnext/erpnext/hr/doctype/employee/employee.py +195,Please set User ID field in an Employee record to set Employee Role,Prašome nustatyti vartotojo ID lauką darbuotojas įrašo nustatyti Darbuotojų vaidmuo
DocType: UOM,UOM Name,UOM Vardas
DocType: GST HSN Code,HSN Code,HSN kodas
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +43,Contribution Amount,įnašo suma
DocType: Purchase Invoice,Shipping Address,Pristatymo adresas
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.,Šis įrankis padeda jums atnaujinti arba pataisyti kiekį ir vertinimui atsargų sistemoje. Ji paprastai naudojama sinchronizuoti sistemos vertybes ir kas iš tikrųjų yra jūsų sandėlių.
DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,"Žodžiais bus matomas, kai jūs išgelbėti važtaraštyje."
DocType: Expense Claim,EXP,Tinka
DocType: Water Analysis,Container,Konteineris
apps/erpnext/erpnext/education/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Studentų {0} - {1} pasirodo kelis kartus iš eilės {2} ir {3}
DocType: Healthcare Settings,Manage Sample Collection,Tvarkykite pavyzdžių rinkinį
DocType: Patient,Tobacco Past Use,Tabako praeitis
DocType: Sales Invoice Item,Brand Name,Markės pavadinimas
DocType: Purchase Receipt,Transporter Details,Transporter detalės
apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +65,User {0} is already assigned to Physician {1},Naudotojas {0} jau yra priskirtas gydytojui {1}
apps/erpnext/erpnext/accounts/page/pos/pos.js +2658,Default warehouse is required for selected item,Numatytasis sandėlis reikalingas pasirinktą elementą
apps/erpnext/erpnext/utilities/user_progress.py +143,Box,Dėžė
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1036,Possible Supplier,galimas Tiekėjas
DocType: Budget,Monthly Distribution,Mėnesio pasiskirstymas
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68,Receiver List is empty. Please create Receiver List,Imtuvas sąrašas tuščias. Prašome sukurti imtuvas sąrašas
apps/erpnext/erpnext/public/js/setup_wizard.js +31,Healthcare (beta),Sveikatos priežiūra (beta)
DocType: Production Plan Sales Order,Production Plan Sales Order,Gamybos planas pardavimų užsakymų
DocType: Sales Partner,Sales Partner Target,Partneriai pardavimo Tikslinė
DocType: Loan Type,Maximum Loan Amount,Maksimali paskolos suma
DocType: Pricing Rule,Pricing Rule,kainodaros taisyklė
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Dublikatas ritinys numeris studentas {0}
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Dublikatas ritinys numeris studentas {0}
DocType: Budget,Action if Annual Budget Exceeded,"Veiksmų, jei metinio biudžeto Viršytas"
apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,Medžiaga Prašymas Pirkimo užsakymas
DocType: Shopping Cart Settings,Payment Success URL,Mokėjimo Sėkmės adresas
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +80,Row # {0}: Returned Item {1} does not exists in {2} {3},Eilutės # {0}: grąžinama prekė {1} nėra egzistuoja {2} {3}
DocType: Purchase Receipt,PREC-,PREC-
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16,Bank Accounts,Banko sąskaitos
,Bank Reconciliation Statement,Bankas Susitaikymas pareiškimas
DocType: Consultation,Medical Coding,Medicininis kodavimas
DocType: Healthcare Settings,Reminder Message,Priminimo pranešimas
,Lead Name,Švinas Vardas
,POS,POS
DocType: C-Form,III,III
apps/erpnext/erpnext/config/stock.py +310,Opening Stock Balance,Atidarymo sandėlyje balansas
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58,{0} must appear only once,{0} turi būti tik vieną kartą
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,Leaves Allocated Successfully for {0},Lapai Paskirti sėkmingai {0}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42,No Items to pack,Neturite prekių pakuotės
DocType: Shipping Rule Condition,From Value,nuo Vertė
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +586,Manufacturing Quantity is mandatory,Gamyba Kiekis yra privalomi
DocType: Employee Loan,Repayment Method,grąžinimas būdas
DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Jei pažymėta, Titulinis puslapis bus numatytasis punktas grupė svetainėje"
DocType: Quality Inspection Reading,Reading 4,svarstymą 4
apps/erpnext/erpnext/config/hr.py +132,Claims for company expense.,Ieškiniai dėl įmonės sąskaita.
apps/erpnext/erpnext/utilities/activation.py +118,"Students are at the heart of the system, add all your students","Studentai ne sistemos širdyje, pridėti visus savo mokinius"
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +81,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Eilutės # {0} klirensas data {1} negali būti prieš čekis data {2}
DocType: Asset Maintenance Task,Certificate Required,Reikalingas sertifikatas
DocType: Company,Default Holiday List,Numatytasis poilsis sąrašas
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +190,Row {0}: From Time and To Time of {1} is overlapping with {2},Eilutės {0}: Nuo laiką ir Laikas {1} iš dalies sutampa su {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145,Stock Liabilities,Akcijų Įsipareigojimai
DocType: Purchase Invoice,Supplier Warehouse,tiekėjas tiekiantis sandėlis
DocType: Opportunity,Contact Mobile No,Kontaktinė Mobilus Nėra
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +389,Select Company,Pasirinkite įmonę
,Material Requests for which Supplier Quotations are not created,Medžiaga Prašymai dėl kurių Tiekėjas Citatos nėra sukurtos
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.,Vartotojas {0} neturi numatytojo POS profilio. Patikrinkite numatytuosius šio vartotojo {1} eilutėje (1).
DocType: Student Group,Set 0 for no limit,Nustatykite 0 jokios ribos
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +141,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,"Dieną (-os), kada prašote atostogų yra šventės. Jums nereikia prašyti atostogų."
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64,Row {idx}: {field} is required to create the Opening {invoice_type} Invoices,"Rida {idx}: {field} reikalinga, kad būtų sukurtos &quot;Opening {invoice_type}&quot; sąskaitos faktūros"
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,Persiųsti Mokėjimo paštu
apps/erpnext/erpnext/templates/pages/projects.html +27,New task,Nauja užduotis
DocType: Consultation,Appointment,Paskyrimas
apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Padaryti Citata
apps/erpnext/erpnext/config/selling.py +216,Other Reports,Kiti pranešimai
apps/erpnext/erpnext/public/js/setup_wizard.js +39,Please select at least one domain.,Pasirinkite bent vieną domeną.
DocType: Dependent Task,Dependent Task,priklauso nuo darbo
apps/erpnext/erpnext/stock/doctype/item/item.py +430,Conversion factor for default Unit of Measure must be 1 in row {0},Konversijos koeficientas pagal nutylėjimą Matavimo vienetas turi būti 1 eilės {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +208,Leave of type {0} cannot be longer than {1},Atostogos tipo {0} negali būti ilgesnis nei {1}
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Pabandykite planuoja operacijas X dienų iš anksto.
DocType: HR Settings,Stop Birthday Reminders,Sustabdyti Gimimo diena Priminimai
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235,Please set Default Payroll Payable Account in Company {0},Prašome Set Default Darbo užmokesčio MOKĖTINOS Narystė Bendrovėje {0}
DocType: SMS Center,Receiver List,imtuvas sąrašas
apps/erpnext/erpnext/accounts/page/pos/pos.js +1084,Search Item,Paieška punktas
DocType: Payment Schedule,Payment Amount,Mokėjimo suma
DocType: Patient Appointment,Referring Physician,Kreipiantis gydytojas
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,suvartoti suma
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +98,Net Change in Cash,Grynasis Pakeisti pinigais
DocType: Assessment Plan,Grading Scale,vertinimo skalė
apps/erpnext/erpnext/stock/doctype/item/item.py +425,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Matavimo vienetas {0} buvo įrašytas daugiau nei vieną kartą konversijos koeficientas lentelėje
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +617,Already completed,jau baigtas
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock In Hand,Akcijų In Hand
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64,Import Successful!,Importas sėkmingai!
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29,Payment Request already exists {0},Mokėjimo prašymas jau yra {0}
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Kaina išduotą prekės
DocType: Physician,Hospital,Ligoninė
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +385,Quantity must not be more than {0},Kiekis turi būti ne daugiau kaip {0}
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117,Previous Financial Year is not closed,Praėję finansiniai metai yra neuždarytas
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46,Age (Days),Amžius (dienomis)
DocType: Quotation Item,Quotation Item,citata punktas
DocType: Customer,Customer POS Id,Klientų POS ID
DocType: Account,Account Name,Paskyros vardas
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40,From Date cannot be greater than To Date,Nuo data negali būti didesnis nei data
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198,Serial No {0} quantity {1} cannot be a fraction,Serijos Nr {0} kiekis {1} negali būti frakcija
apps/erpnext/erpnext/config/buying.py +43,Supplier Type master.,Tiekėjas tipas meistras.
DocType: Purchase Order Item,Supplier Part Number,Tiekėjas Dalies numeris
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108,Conversion rate cannot be 0 or 1,Perskaičiavimo kursas negali būti 0 arba 1
DocType: Subscription,Reference Document,Informacinis dokumentas
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +209,{0} {1} is cancelled or stopped,{0} {1} yra atšauktas arba sustabdytas
DocType: Accounts Settings,Credit Controller,kredito valdiklis
DocType: Grant Application,Applicant Type,Pareiškėjo tipas
DocType: Delivery Note,Vehicle Dispatch Date,Automobilio išsiuntimo data
DocType: Healthcare Settings,Default Medical Code Standard,Numatytasis medicinos kodekso standartas
DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237,Purchase Receipt {0} is not submitted,Pirkimo kvito {0} nebus pateiktas
DocType: Company,Default Payable Account,Numatytasis Mokėtina paskyra
apps/erpnext/erpnext/config/website.py +17,"Settings for online shopping cart such as shipping rules, price list etc.","Nustatymai internetinėje krepšelį pavyzdžiui, laivybos taisykles, kainoraštį ir tt"
apps/erpnext/erpnext/controllers/website_list_for_contact.py +113,{0}% Billed,{0}% Įvardintas
apps/erpnext/erpnext/hub_node/page/hub/hub.js +179,Sort by Price ...,Rūšiuoti pagal kainą ...
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18,Reserved Qty,saugomos Kiekis
DocType: Party Account,Party Account,šalis paskyra
apps/erpnext/erpnext/config/setup.py +122,Human Resources,Žmogiškieji ištekliai
DocType: Lead,Upper Income,viršutinė pajamos
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17,Reject,atmesti
DocType: Journal Entry Account,Debit in Company Currency,Debeto įmonėje Valiuta
DocType: BOM Item,BOM Item,BOM punktas
DocType: Appraisal,For Employee,darbuotojo
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49,Make Disbursement Entry,Padaryti Išmok ÷ jimo įrašas
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Supplier must be debit,Eilutės {0}: Išankstinis prieš Tiekėjas turi būti nurašyti
DocType: Company,Default Values,numatytosios vertės
DocType: Membership,INR,INR
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60,{frequency} Digest,{Dažnis} Digest &quot;
DocType: Expense Claim,Total Amount Reimbursed,Iš viso kompensuojama suma
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5,This is based on logs against this Vehicle. See timeline below for details,Tai grindžiama rąstų prieš šią transporto priemonę. Žiūrėti grafikas žemiau detales
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90,Against Supplier Invoice {0} dated {1},Prieš tiekėjo sąskaitoje {0} data {1}
DocType: Customer,Default Price List,Numatytasis Kainų sąrašas
apps/erpnext/erpnext/assets/doctype/asset/asset.py +269,Asset Movement record {0} created,Turto Judėjimo įrašas {0} sukūrė
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,Jūs negalite trinti finansiniai metai {0}. Finansiniai metai {0} yra numatytoji Global Settings
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,A customer with the same name already exists,Tokio paties kliento klientas jau egzistuoja
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +183,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Tai pateikia Atlyginimo lapelius ir sukuria kaupimo žurnalo įrašą. Ar norite testi?
DocType: Purchase Invoice,Total Net Weight,Bendras grynasis svoris
DocType: Journal Entry,Entry Type,įrašo tipas
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +44,No assessment plan linked with this assessment group,Nėra vertinimo planas susijęs su šio vertinimo grupės
,Customer Credit Balance,Klientų kredito likučio
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23,Net Change in Accounts Payable,Grynasis pokytis mokėtinos sumos
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',Klientų reikalinga &quot;Customerwise nuolaidų&quot;
apps/erpnext/erpnext/config/accounts.py +140,Update bank payment dates with journals.,Atnaujinkite banko mokėjimo datos ir žurnaluose.
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21,Pricing,Kainos
DocType: Quotation,Term Details,Terminuoti detalės
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,Negalima registruotis daugiau nei {0} studentams šio studentų grupę.
apps/erpnext/erpnext/templates/print_formats/includes/total.html +4,Total (Without Tax),Iš viso (be mokesčio)
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Švinas Grafas
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Švinas Grafas
apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} turi būti didesnis nei 0
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +30,Stock Available,Sandėlyje galima
DocType: Manufacturing Settings,Capacity Planning For (Days),Talpa planavimas (dienos)
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10,Procurement,Viešųjų pirkimų
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +66,None of the items have any change in quantity or value.,Nė vienas iš daiktų turite kokių nors kiekio ar vertės pokyčius.
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17,Mandatory field - Program,Privalomas laukas - Programa
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17,Mandatory field - Program,Privalomas laukas - Programa
DocType: Special Test Template,Result Component,Rezultato komponentas
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46,Warranty Claim,Garantija Pretenzija
,Lead Details,Švino detalės
DocType: Volunteer,Availability and Skills,Prieinamumas ir įgūdžiai
DocType: Salary Slip,Loan repayment,paskolos grąžinimo
DocType: Purchase Invoice,End date of current invoice's period,Pabaigos data einamųjų sąskaitos faktūros laikotarpį
DocType: Pricing Rule,Applicable For,taikytina
DocType: Lab Test,Technician Name,Technikos vardas
DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Atsieti Apmokėjimas atšaukimas sąskaita faktūra
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Dabartinis Odometro skaitymo įvesta turėtų būti didesnis nei pradinis transporto priemonės hodometro {0}
DocType: Restaurant Reservation,No Show,Nr šou
DocType: Shipping Rule Country,Shipping Rule Country,Pristatymas taisyklė Šalis
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10,Leave and Attendance,Palikite ir lankymas
DocType: Maintenance Visit,Partially Completed,dalinai užpildytą
apps/erpnext/erpnext/healthcare/setup.py +257,Moderate Sensitivity,Vidutinis jautrumas
DocType: Leave Type,Include holidays within leaves as leaves,Įtraukti atostogas per lapus kaip lapai
DocType: Sales Invoice,Packed Items,Fasuoti daiktai
apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Garantija pretenzija Serijos Nr
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +71,'Total',&quot;Iš viso&quot;
DocType: Shopping Cart Settings,Enable Shopping Cart,Įjungti Prekių krepšelis
DocType: Employee,Permanent Address,Nuolatinis adresas
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +258,"Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}",Iš anksto sumokėta prieš {0} {1} negali būti didesnis \ nei IŠ VISO {2}
DocType: Patient,Medication,Vaistas
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147,Please select item code,Prašome pasirinkti Prekės kodas
DocType: Student Sibling,Studying in Same Institute,Studijos pačiu instituto
DocType: Territory,Territory Manager,teritorija direktorius
DocType: Packed Item,To Warehouse (Optional),Į sandėlį (neprivalomas)
DocType: GST Settings,GST Accounts,GST sąskaitos
DocType: Payment Entry,Paid Amount (Company Currency),Mokama suma (Įmonės valiuta)
DocType: Purchase Invoice,Additional Discount,Papildoma nuolaida
DocType: Selling Settings,Selling Settings,parduoda Nustatymai
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83,Confirm Action,Patvirtinti veiksmą
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39,Online Auctions,Dabar Aukcionai
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +100,Please specify either Quantity or Valuation Rate or both,Prašome nurodyti arba kiekis ar Vertinimo norma arba abu
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18,Fulfillment,įvykdymas
apps/erpnext/erpnext/templates/generators/item.html +67,View in Cart,Žiūrėti krepšelį
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103,Marketing Expenses,rinkodaros išlaidos
,Item Shortage Report,Prekė trūkumas ataskaita
apps/erpnext/erpnext/stock/doctype/item/item.js +275,"Weight is mentioned,\nPlease mention ""Weight UOM"" too",Svoris paminėta \ nLūdzu paminėti &quot;Svoris UOM&quot; per
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,"Medžiaga Prašymas naudojamas, kad šių išteklių įrašas"
apps/erpnext/erpnext/assets/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Kitas Nusidėvėjimas data yra privalomas naujo turto
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Atskiras kursas grindžiamas grupė kiekvieną partiją
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Atskiras kursas grindžiamas grupė kiekvieną partiją
apps/erpnext/erpnext/config/support.py +32,Single unit of an Item.,Vieno vieneto elementą.
DocType: Fee Category,Fee Category,mokestis Kategorija
DocType: Agriculture Task,Next Business Day,Kitas verslo diena
DocType: Customer,Primary Contact Detail,Pirminio kontaktinio asmens duomenys
DocType: Drug Prescription,Dosage by time interval,Dozavimas pagal laiko intervalą
,Student Fee Collection,Studentų mokestis kolekcija
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +23,Appointment Duration (mins),Paskyrimo trukmė (min.)
DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Padaryti apskaitos įrašas Kiekvienas vertybinių popierių judėjimo
DocType: Leave Allocation,Total Leaves Allocated,Iš viso Lapai Paskirti
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163,Warehouse required at Row No {0},Sandėlių reikalaujama Row Nr {0}
apps/erpnext/erpnext/public/js/setup_wizard.js +142,Please enter valid Financial Year Start and End Dates,Prašome įvesti galiojantį finansinių metų pradžios ir pabaigos datos
DocType: Employee,Date Of Retirement,Data nuo išėjimo į pensiją
DocType: Upload Attendance,Get Template,Gauk šabloną
DocType: Material Request,Transferred,Perduotas
DocType: Vehicle,Doors,durys
apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117,ERPNext Setup Complete!,ERPNext sąranka baigta
DocType: Healthcare Settings,Collect Fee for Patient Registration,Rinkti paciento registracijos mokestį
apps/erpnext/erpnext/stock/doctype/item/item.py +650,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Negalima keisti požymių po atsargų sandorio. Padarykite naują prekę ir perkelkite akcijas į naują prekę
DocType: Course Assessment Criteria,Weightage,weightage
DocType: Purchase Invoice,Tax Breakup,mokesčių Breakup
DocType: Packing Slip,PS-,PS
DocType: Member,Non Profit Member,Ne pelno narys
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}: Kaina centras yra reikalingas &quot;Pelno ir nuostolio&quot; sąskaitos {2}. Prašome įkurti numatytąją sąnaudų centro bendrovei.
DocType: Payment Schedule,Payment Term,Mokėjimo terminas
apps/erpnext/erpnext/selling/doctype/customer/customer.py +146,A Customer Group exists with same name please change the Customer name or rename the Customer Group,Klientų grupė egzistuoja to paties pavadinimo prašome pakeisti kliento vardą arba pervardyti klientų grupei
DocType: Land Unit,Area,Plotas
apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,nauja Susisiekite
DocType: Territory,Parent Territory,tėvų teritorija
DocType: Sales Invoice,Place of Supply,Tiekimo vieta
DocType: Quality Inspection Reading,Reading 2,Skaitymas 2
DocType: Stock Entry,Material Receipt,medžiaga gavimas
DocType: Homepage,Products,produktai
DocType: Announcement,Instructor,Instruktorius
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61,Select Item (optional),Pasirinkite elementą (neprivaloma)
DocType: Fee Schedule Student Group,Fee Schedule Student Group,Mokesčių lentelė Studentų grupė
DocType: Student,AB+,AB &quot;+&quot;
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Jei ši prekė yra variantų, tada jis negali būti parenkamos pardavimo užsakymus ir tt"
DocType: Lead,Next Contact By,Kitas Susisiekti
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +314,Quantity required for Item {0} in row {1},reikalingas punktas {0} iš eilės Kiekis {1}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +46,Warehouse {0} can not be deleted as quantity exists for Item {1},"Sandėlių {0} negali būti išbrauktas, nes egzistuoja kiekis už prekę {1}"
DocType: Quotation,Order Type,pavedimo tipas
,Item-wise Sales Register,Prekė išmintingas Pardavimų Registruotis
DocType: Asset,Gross Purchase Amount,Pilna Pirkimo suma
apps/erpnext/erpnext/utilities/user_progress.py +36,Opening Balances,Atidarymo likučiai
DocType: Asset,Depreciation Method,nusidėvėjimo metodas
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Ar šis mokestis įtrauktas į bazinę palūkanų normą?
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,Iš viso Tikslinė
DocType: Soil Texture,Sand Composition (%),Smėlio sudedamoji dalis (%)
DocType: Job Applicant,Applicant for a Job,Pareiškėjas dėl darbo
DocType: Production Plan Material Request,Production Plan Material Request,Gamybos planas Medžiaga Prašymas
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231,No Production Orders created,Nieko gamybos užsakymų sukurtas
DocType: Stock Reconciliation,Reconciliation JSON,susitaikymas JSON
apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,Per daug stulpelių. Eksportuoti ataskaitą ir jį atspausdinti naudojant skaičiuoklės programą.
DocType: Purchase Invoice Item,Batch No,Serijos Nr
DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Leisti kelis pardavimų užsakymų prieš Kliento Užsakymo
DocType: Student Group Instructor,Student Group Instructor,Studentų grupė instruktorius
DocType: Student Group Instructor,Student Group Instructor,Studentų grupė instruktorius
DocType: Grant Application,Assessment  Mark (Out of 10),Vertinimo ženklas (iš 10)
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Guardian2 Mobilus Nėra
apps/erpnext/erpnext/setup/doctype/company/company.py +207,Main,pagrindinis
apps/erpnext/erpnext/stock/doctype/item/item.js +72,Variant,variantas
DocType: Naming Series,Set prefix for numbering series on your transactions,Nustatyti priešdėlis numeracijos seriją apie sandorius savo
DocType: Employee Attendance Tool,Employees HTML,darbuotojai HTML
apps/erpnext/erpnext/stock/doctype/item/item.py +444,Default BOM ({0}) must be active for this item or its template,Numatytasis BOM ({0}) turi būti aktyvus šią prekę ar jo šabloną
DocType: Employee,Leave Encashed?,Palikite Encashed?
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Galimybė Nuo srityje yra privalomas
DocType: Email Digest,Annual Expenses,metinės išlaidos
DocType: Item,Variants,variantai
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1137,Make Purchase Order,Padaryti pirkinių užsakymą
DocType: SMS Center,Send To,siųsti
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +152,There is not enough leave balance for Leave Type {0},Nėra pakankamai atostogos balansas Palikti tipas {0}
DocType: Payment Reconciliation Payment,Allocated amount,skirtos sumos
DocType: Sales Team,Contribution to Net Total,Indėlis į grynuosius
DocType: Sales Invoice Item,Customer's Item Code,Kliento punktas kodas
DocType: Stock Reconciliation,Stock Reconciliation,akcijų suderinimas
DocType: Territory,Territory Name,teritorija Vardas
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +197,Work-in-Progress Warehouse is required before Submit,Darbas-in-progress sandėlio reikalingas prieš Pateikti
apps/erpnext/erpnext/config/hr.py +40,Applicant for a Job.,Kandidatui į darbą.
DocType: Purchase Order Item,Warehouse and Reference,Sandėliavimo ir nuoroda
DocType: Supplier,Statutory info and other general information about your Supplier,Teisės aktų informacijos ir kita bendra informacija apie jūsų tiekėjas
DocType: Item,Serial Nos and Batches,Eilės Nr ir Partijos
DocType: Item,Serial Nos and Batches,Eilės Nr ir Partijos
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Studentų grupė Stiprumas
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Studentų grupė Stiprumas
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +250,Against Journal Entry {0} does not have any unmatched {1} entry,Prieš leidinyje Įėjimo {0} neturi neprilygstamą {1} įrašą
apps/erpnext/erpnext/config/hr.py +142,Appraisals,vertinimai
apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8,Training Events,Mokymo renginiai
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205,Duplicate Serial No entered for Item {0},Duplicate Serijos Nr įvestas punkte {0}
DocType: Shipping Rule Condition,A condition for a Shipping Rule,Sąlyga laivybos taisyklės
apps/erpnext/erpnext/hr/doctype/employee/employee.py +167,Please enter ,Prašome įvesti
apps/erpnext/erpnext/controllers/accounts_controller.py +487,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Buying Settings","Negali overbill už prekę {0} iš eilės {1} daugiau nei {2}. Leisti per lpi, prašome nustatyti Ieško Nustatymai"
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43,Maintenance Log,Techninės priežiūros žurnalas
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +234,Please set filter based on Item or Warehouse,Prašome nustatyti filtrą remiantis punktą arba sandėlyje
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Grynasis svoris šio paketo. (Skaičiuojama automatiškai suma neto masė daiktų)
DocType: Sales Order,To Deliver and Bill,Pristatyti ir Bill
DocType: Student Group,Instructors,instruktoriai
DocType: GL Entry,Credit Amount in Account Currency,Kredito sumą sąskaitos valiuta
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +588,BOM {0} must be submitted,BOM {0} turi būti pateiktas
DocType: Authorization Control,Authorization Control,autorizacija Valdymo
apps/erpnext/erpnext/controllers/buying_controller.py +327,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Eilutės # {0}: Atmesta Sandėlis yra privalomas prieš atmetė punkte {1}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +808,Payment,mokėjimas
apps/erpnext/erpnext/controllers/stock_controller.py +92,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Sandėlių {0} nėra susijęs su bet kokios sąskaitos, nurodykite Sandėlį įrašo sąskaitą arba nustatyti numatytąją inventoriaus sąskaitą įmonę {1}."
apps/erpnext/erpnext/utilities/activation.py +81,Manage your orders,Tvarkykite savo užsakymus
DocType: Production Order Operation,Actual Time and Cost,Tikrasis Laikas ir kaina
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +54,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Medžiaga Prašymas maksimalių {0} galima už prekę {1} prieš Pardavimų ordino {2}
DocType: Crop,Crop Spacing,Pasėlių atstumas
DocType: Course,Course Abbreviation,Žinoma santrumpa
DocType: Student Leave Application,Student Leave Application,Studentų atostogos taikymas
DocType: Item,Will also apply for variants,Bus taikoma variantų
apps/erpnext/erpnext/assets/doctype/asset/asset.py +164,"Asset cannot be cancelled, as it is already {0}","Turto negali būti atšauktas, nes jis jau yra {0}"
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} on Half day on {1},Darbuotojų {0} pusę dienos {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42,Total working hours should not be greater than max working hours {0},Iš viso darbo valandų turi būti ne didesnis nei maks darbo valandų {0}
apps/erpnext/erpnext/templates/pages/task_info.html +90,On,apie
apps/erpnext/erpnext/config/selling.py +62,Bundle items at time of sale.,Rinkinys daiktų metu pardavimas.
DocType: Quotation Item,Actual Qty,Tikrasis Kiekis
DocType: Sales Invoice Item,References,Nuorodos
DocType: Quality Inspection Reading,Reading 10,Skaitymas 10
DocType: Hub Category,Hub Node,Stebulės mazgas
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,Jūs įvedėte pasikartojančius elementus. Prašome ištaisyti ir bandykite dar kartą.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129,Associate,Bendradarbis
DocType: Asset Movement,Asset Movement,turto judėjimas
apps/erpnext/erpnext/accounts/page/pos/pos.js +2181,New Cart,nauja krepšelį
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,Prekė {0} nėra išspausdintas punktas
DocType: SMS Center,Create Receiver List,Sukurti imtuvas sąrašas
DocType: Vehicle,Wheels,ratai
DocType: Packing Slip,To Package No.,Paketas Nr
DocType: Patient Relation,Family,Šeima
DocType: Production Planning Tool,Material Requests,Medžiaga Prašymai
DocType: Warranty Claim,Issue Date,Išdavimo data
DocType: Activity Cost,Activity Cost,veiklos sąnaudos
DocType: Sales Invoice Timesheet,Timesheet Detail,Lapą detalės
DocType: Purchase Receipt Item Supplied,Consumed Qty,suvartoti Kiekis
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52,Telecommunications,Telekomunikacijos
apps/erpnext/erpnext/accounts/party.py +266,Billing currency must be equal to either default company's currency or party account currency,"Atsiskaitymo valiuta turi būti lygi arba numatytojo įmonės valiuta, arba šalies sąskaitos valiuta"
DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),"Nurodo, kad paketas yra šio pristatymo (tik projekto) dalis"
DocType: Soil Texture,Loam,Loam
apps/erpnext/erpnext/controllers/accounts_controller.py +700,Row {0}: Due Date cannot be before posting date,Eilutė {0}: mokėjimo data negali būti prieš paskelbimo datą
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36,Make Payment Entry,Padaryti Mokėjimo įrašą
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129,Quantity for Item {0} must be less than {1},Kiekis už prekę {0} turi būti mažesnis nei {1}
,Sales Invoice Trends,Pardavimo sąskaita-faktūra tendencijos
DocType: Leave Application,Apply / Approve Leaves,Taikyti / Patvirtinti lapai
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,For,Dėl
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +167,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Gali kreiptis eilutę tik jei įkrova tipas &quot;Dėl ankstesnės eilės suma&quot; ar &quot;ankstesnės eilės Total&quot;
DocType: Sales Order Item,Delivery Warehouse,Pristatymas sandėlis
apps/erpnext/erpnext/config/accounts.py +241,Tree of financial Cost Centers.,Medis finansinių išlaidų centrai.
DocType: Serial No,Delivery Document No,Pristatymas dokumentas Nr
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Prašome nustatyti &quot;Gain / Loss sąskaitą turto perdavimo&quot; Bendrovėje {0}
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Gauti prekes iš įsigijimo kvitai
DocType: Serial No,Creation Date,Sukūrimo data
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33,Item {0} appears multiple times in Price List {1},Prekė {0} kainoraštyje {1} rodoma keletą kartų
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +40,"Selling must be checked, if Applicable For is selected as {0}","Parduodami turi būti patikrinta, jei taikoma pasirinkta kaip {0}"
DocType: Production Plan Material Request,Material Request Date,Medžiaga Prašymas data
DocType: Purchase Order Item,Supplier Quotation Item,Tiekėjas Citata punktas
DocType: Manufacturing Settings,Disables creation of time logs against Production Orders. Operations shall not be tracked against Production Order,Išjungia kūrimą laiko rąstų prieš Gamybos užsakymus. Veikla neturi būti stebimi nuo gamybos ordino
DocType: Student,Student Mobile Number,Studentų Mobilusis Telefonas Numeris
DocType: Item,Has Variants,turi variantams
apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Atnaujinti atsakymą
apps/erpnext/erpnext/public/js/utils.js +226,You have already selected items from {0} {1},Jūs jau pasirinkote elementus iš {0} {1}
DocType: Monthly Distribution,Name of the Monthly Distribution,Pavadinimas Mėnesio pasiskirstymas
apps/erpnext/erpnext/stock/doctype/batch/batch.py +46,Batch ID is mandatory,Serija ID privalomi
apps/erpnext/erpnext/stock/doctype/batch/batch.py +46,Batch ID is mandatory,Serija ID privalomi
DocType: Sales Person,Parent Sales Person,Tėvų pardavimų asmuo
apps/erpnext/erpnext/hub_node/page/hub/hub.js +180,High to Low,Nuo didelio iki mažo
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24,Select the program first,Pirmiausia pasirinkite programą
DocType: Patient Appointment,Patient Age,Paciento amžius
apps/erpnext/erpnext/config/learn.py +263,Managing Projects,projektų valdymas
DocType: Supplier,Supplier of Goods or Services.,Tiekėjas tiekiantis prekes ar paslaugas.
DocType: Budget,Fiscal Year,Fiskaliniai metai
DocType: Asset Maintenance Log,Planned,Planuojama
DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Consultation charges.,"Numatytos gautinos sąskaitos, kurios bus naudojamos, jei nenustatytos Pacientui, kad galėtumėte užsisakyti konsultacijų mokesčius."
DocType: Vehicle Log,Fuel Price,kuro Kaina
DocType: Budget,Budget,biudžetas
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +51,Set Open,Nustatyti Atidaryti
apps/erpnext/erpnext/stock/doctype/item/item.py +247,Fixed Asset Item must be a non-stock item.,Ilgalaikio turto turi būti ne akcijų punktas.
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Biudžetas negali būti skiriamas prieš {0}, nes tai ne pajamos ar sąnaudos sąskaita"
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,pasiektas
DocType: Student Admission,Application Form Route,Prašymo forma Vartojimo būdas
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66,Territory / Customer,Teritorija / Klientų
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44,Leave Type {0} cannot be allocated since it is leave without pay,"Palikite tipas {0} negali būti paskirstytos, nes ji yra palikti be darbo užmokesčio"
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +166,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Eilutės {0}: Paskirti suma {1} turi būti mažesnis arba lygus sąskaitą skolos likutį {2}
DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,"Žodžiais bus matomas, kai įrašote pardavimo sąskaita-faktūra."
DocType: Lead,Follow Up,Sekti
DocType: Item,Is Sales Item,Ar Pardavimų punktas
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21,Item Group Tree,Prekė Grupė medis
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69,Item {0} is not setup for Serial Nos. Check Item master,Prekė {0} nėra setup Serijos Nr. Patikrinkite Elementą meistras
DocType: Maintenance Visit,Maintenance Time,Priežiūros laikas
,Amount to Deliver,Suma pristatyti
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +324,Same item has been entered multiple times. {0},Tas pats elementas buvo įvestas keletą kartų. {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.,"Term pradžios data negali būti vėlesnė nei metų pradžioje data mokslo metams, kuris terminas yra susijęs (akademiniai metai {}). Ištaisykite datas ir bandykite dar kartą."
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +192,There were errors.,Nebuvo klaidų.
DocType: Guardian,Guardian Interests,Guardian Pomėgiai
DocType: Naming Series,Current Value,Dabartinė vertė
apps/erpnext/erpnext/controllers/accounts_controller.py +272,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Keli fiskalinius metus egzistuoja datos {0}. Prašome nustatyti bendrovės finansiniams metams
DocType: Education Settings,Instructor Records to be created by,"Instruktorių įrašai, kuriuos turi sukurti"
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229,{0} created,{0} sukūrė
DocType: GST Account,GST Account,GST sąskaita
DocType: Delivery Note Item,Against Sales Order,Prieš Pardavimų ordino
,Serial No Status,Serijos Nr Būsena
DocType: Payment Entry Reference,Outstanding,neišspręstas
DocType: Supplier,Warn POs,Įspėti PO
,Daily Timesheet Summary,Dienos Lapą santrauka
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137,"Row {0}: To set {1} periodicity, difference between from and to date \
						must be greater than or equal to {2}","Eilutės {0}: Norėdami nustatyti {1} periodiškumas, skirtumas tarp iš ir į datą \ turi būti didesnis nei arba lygus {2}"
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,Tai remiantis akcijų judėjimo. Žiūrėti {0} daugiau informacijos
DocType: Pricing Rule,Selling,pardavimas
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +379,Amount {0} {1} deducted against {2},Suma {0} {1} išskaičiuota nuo {2}
DocType: Employee,Salary Information,Pajamos Informacija
DocType: Sales Person,Name and Employee ID,Vardas ir darbuotojo ID
apps/erpnext/erpnext/accounts/party.py +311,Due Date cannot be before Posting Date,Terminas negali būti prieš paskelbdami data
DocType: Website Item Group,Website Item Group,Interneto svetainė punktas grupė
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Duties and Taxes,Muitai ir mokesčiai
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,Please enter Reference date,Prašome įvesti Atskaitos data
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} mokėjimo įrašai negali būti filtruojamas {1}
DocType: Item Website Specification,Table for Item that will be shown in Web Site,"Staliukas elementą, kuris bus rodomas svetainėje"
DocType: Purchase Order Item Supplied,Supplied Qty,Tiekiami Kiekis
DocType: Purchase Order Item,Material Request Item,Medžiaga Prašymas punktas
apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Medis punktas grupes.
DocType: Payroll Entry,Get Employee Details,Gaukite darbuotojų informaciją
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177,Cannot refer row number greater than or equal to current row number for this Charge type,Negali remtis eilutės skaičius didesnis nei arba lygus dabartinės eilutės numeris Šio mokesčio tipą
DocType: Asset,Sold,parduota
,Item-wise Purchase History,Prekė išmintingas pirkimas Istorija
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},Prašome spausti &quot;Generuoti grafiką&quot; parsiųsti Serijos Nr pridėta punkte {0}
DocType: Account,Frozen,užšalęs
,Open Production Orders,Atviri gamybos užsakymus
DocType: Sales Invoice Payment,Base Amount (Company Currency),Bazinė suma (Įmonės valiuta)
DocType: Payment Reconciliation Payment,Reference Row,nuoroda eilutė
DocType: Installation Note,Installation Time,montavimo laikas
DocType: Sales Invoice,Accounting Details,apskaitos informacija
apps/erpnext/erpnext/setup/doctype/company/company.js +113,Delete all the Transactions for this Company,Ištrinti visus sandorių šiai bendrovei
DocType: Patient,O Positive,O teigiamas
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +200,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Eilutės # {0}: Operacija {1} nėra baigtas {2} Kiekis gatavų prekių gamybos Užsakyti # {3}. Atnaujinkite veikimo būseną per Time Įrašai
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Investments,investicijos
DocType: Issue,Resolution Details,geba detalės
apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,asignavimai
DocType: Item Quality Inspection Parameter,Acceptance Criteria,priimtinumo kriterijai
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159,Please enter Material Requests in the above table,Prašome įvesti Materialieji prašymus pirmiau pateiktoje lentelėje
DocType: Item Attribute,Attribute Name,atributo pavadinimas
DocType: BOM,Show In Website,Rodyti svetainė
DocType: Shopping Cart Settings,Show Quantity in Website,Rodyti Kiekis svetainė
DocType: Employee Loan Application,Total Payable Amount,Iš viso mokėtina suma
DocType: Task,Expected Time (in hours),Numatomas laikas (valandomis)
DocType: Item Reorder,Check in (group),Atvykimas (grupė)
DocType: Soil Texture,Silt,Silt
,Qty to Order,Kiekis užsisakyti
DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Sąskaitos galva pagal įsipareigojimą arba nuosavybės, kurioje Pelnas / nuostolis bus nubaustas"
apps/erpnext/erpnext/config/projects.py +31,Gantt chart of all tasks.,Ganto diagrama visų užduočių.
DocType: Opportunity,Mins to First Response,Min First Response
DocType: Pricing Rule,Margin Type,marža tipas
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15,{0} hours,{0} valandos
DocType: Course,Default Grading Scale,Numatytasis vertinimo skalė
DocType: Appraisal,For Employee Name,Darbuotojo Vardas
DocType: Holiday List,Clear Table,Išvalyti lentelė
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +106,Available slots,Galimos laiko tarpsniai
DocType: C-Form Invoice Detail,Invoice No,sąskaitoje Nr
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +350,Make Payment,Sumokėti
DocType: Room,Room Name,Kambarių Vardas
DocType: Prescription Duration,Prescription Duration,Recepto trukmė
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +100,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Palikite negali būti taikomas / atšaukė prieš {0}, kaip atostogos balansas jau perkėlimo persiunčiami būsimos atostogos paskirstymo įrašo {1}"
DocType: Activity Cost,Costing Rate,Sąnaudų norma
apps/erpnext/erpnext/config/selling.py +229,Customer Addresses And Contacts,Klientų Adresai ir kontaktai
,Campaign Efficiency,kampanija efektyvumas
,Campaign Efficiency,kampanija efektyvumas
DocType: Discussion,Discussion,Diskusija
DocType: Payment Entry,Transaction ID,sandorio ID
DocType: Volunteer,Anytime,Anytime
DocType: Patient,Surgical History,Chirurginė istorija
DocType: Employee,Resignation Letter Date,Atsistatydinimas raštas data
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,Pricing Rules are further filtered based on quantity.,Kainodaros taisyklės yra toliau filtruojamas remiantis kiekį.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335,Please set the Date Of Joining for employee {0},Prašome nustatykite data Prisijungimas darbuotojo {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335,Please set the Date Of Joining for employee {0},Prašome nustatykite data Prisijungimas darbuotojo {0}
DocType: Task,Total Billing Amount (via Time Sheet),Iš viso Atsiskaitymo suma (per Time lapas)
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Pakartokite Klientų pajamos
DocType: Soil Texture,Silty Clay Loam,Šilkmedžio sluoksnis
DocType: Chapter,Chapter,Skyrius
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +200,{0} ({1}) must have role 'Expense Approver',{0} ({1}) turi vaidmenį &quot;sąskaita patvirtinusio&quot;
apps/erpnext/erpnext/utilities/user_progress.py +143,Pair,Pora
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +959,Select BOM and Qty for Production,Pasirinkite BOM ir Kiekis dėl gamybos
DocType: Asset,Depreciation Schedule,Nusidėvėjimas Tvarkaraštis
apps/erpnext/erpnext/config/selling.py +124,Sales Partner Addresses And Contacts,Pardavimų Partnerių Adresai ir kontaktai
DocType: Bank Reconciliation Detail,Against Account,prieš sąskaita
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +71,Half Day Date should be between From Date and To Date,Pusė dienos data turi būti tarp Nuo datos ir iki šiol
DocType: Maintenance Schedule Detail,Actual Date,Tikrasis data
DocType: Item,Has Batch No,Turi Serijos Nr
apps/erpnext/erpnext/public/js/utils.js +100,Annual Billing: {0},Metinė Atsiskaitymo: {0}
apps/erpnext/erpnext/config/accounts.py +200,Goods and Services Tax (GST India),Prekių ir paslaugų mokesčio (PVM Indija)
DocType: Delivery Note,Excise Page Number,Akcizo puslapio numeris
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +225,"Company, From Date and To Date is mandatory","Įmonės, Nuo datos ir iki šiol yra privalomi"
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33,Get from Consultation,Paimkite iš konsultacijos
DocType: Asset,Purchase Date,Pirkimo data
DocType: Volunteer,Volunteer Type,Savanorio tipas
DocType: Student,Personal Details,Asmeninės detalės
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193,Please set 'Asset Depreciation Cost Center' in Company {0},Prašome nustatyti &quot;turto nusidėvėjimo sąnaudų centro&quot; įmonėje {0}
,Maintenance Schedules,priežiūros Tvarkaraščiai
DocType: Task,Actual End Date (via Time Sheet),Tikrasis Pabaigos data (per Time lapas)
DocType: Soil Texture,Soil Type,Dirvožemio tipas
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374,Amount {0} {1} against {2} {3},Suma {0} {1} prieš {2} {3}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +318,New Message,Nauja žinutė
,Quotation Trends,Kainų tendencijos
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +159,Item Group not mentioned in item master for item {0},Prekė Grupė nepaminėta prekės šeimininkui už prekę {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +355,Debit To account must be a Receivable account,Debeto sąskaitą turi būti Gautinos sąskaitos
DocType: Shipping Rule,Shipping Amount,Pristatymas suma
DocType: Supplier Scorecard Period,Period Score,Laikotarpio balas
apps/erpnext/erpnext/utilities/user_progress.py +63,Add Customers,Pridėti klientams
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Pending Amount,kol suma
DocType: Lab Test Template,Special,Specialus
DocType: Purchase Order Item Supplied,Conversion Factor,konversijos koeficientas
DocType: Purchase Order,Delivered,Pristatyta
,Vehicle Expenses,Transporto išlaidos
DocType: Serial No,Invoice Details,informacija apie sąskaitą
DocType: Grant Application,Show on Website,Rodyti svetainėje
apps/erpnext/erpnext/assets/doctype/asset/asset.py +159,Expected value after useful life must be greater than or equal to {0},Tikimasi vertė po naudingo tarnavimo laiką turi būti didesnis nei arba lygus {0}
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29,Start on,Pradėk nuo
DocType: Hub Category,Hub Category,Hub kategorija
DocType: Purchase Invoice,SEZ,SEZ
DocType: Purchase Receipt,Vehicle Number,Automobilio numeris
DocType: Employee Loan,Loan Amount,Paskolos suma
apps/erpnext/erpnext/utilities/user_progress.py +88,Add Letterhead,Pridėti burtinę
DocType: Program Enrollment,Self-Driving Vehicle,Savęs Vairavimas automobiliai
DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Tiekėjo rezultatų lentelė nuolatinė
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +420,Row {0}: Bill of Materials not found for the Item {1},Eilutė {0}: bilis medžiagas prekė nerasta {1}
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98,Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,Iš viso skiriami lapai {0} negali būti mažesnė nei jau patvirtintų lapų {1} laikotarpiu
DocType: Journal Entry,Accounts Receivable,gautinos
,Supplier-Wise Sales Analytics,Tiekėjas išmintingas Pardavimų Analytics &quot;
DocType: Salary Structure,Select employees for current Salary Structure,"Pasirinkite darbuotojams už dabartinį darbo užmokesčio struktūrą,"
DocType: Sales Invoice,Company Address Name,Įmonės Adresas Pavadinimas
DocType: Production Order,Use Multi-Level BOM,Naudokite Multi-level BOM
DocType: Bank Reconciliation,Include Reconciled Entries,Įtraukti susitaikė įrašai
DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Tėvų kursai (palikti tuščią, jei tai ne dalis Pagrindinės žinoma)"
DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Tėvų kursai (palikti tuščią, jei tai ne dalis Pagrindinės žinoma)"
DocType: Leave Control Panel,Leave blank if considered for all employee types,"Palikite tuščią, jei laikomas visų darbuotojų tipų"
DocType: Landed Cost Voucher,Distribute Charges Based On,Paskirstykite Mokesčiai remiantis
apps/erpnext/erpnext/hooks.py +144,Timesheets,laiko apskaitos žiniaraščiai
DocType: HR Settings,HR Settings,HR Nustatymai
DocType: Salary Slip,net pay info,neto darbo užmokestis informacijos
DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Ši vertė yra atnaujinta pagal numatytą pardavimo kainoraštį.
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +122,Expense Claim is pending approval. Only the Expense Approver can update status.,Kompensuojamos reikalavimas yra laukiama patvirtinimo. Tik sąskaita Tvirtintojas gali atnaujinti statusą.
DocType: Email Digest,New Expenses,Nauja išlaidos
DocType: Purchase Invoice,Additional Discount Amount,Papildoma Nuolaida suma
DocType: Patient,Patient Details,Paciento duomenys
DocType: Patient,B Positive,B teigiamas
apps/erpnext/erpnext/controllers/accounts_controller.py +595,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Eilutės # {0}: Kiekis turi būti 1, kaip elementas yra ilgalaikio turto. Prašome naudoti atskirą eilutę daugkartiniam vnt."
DocType: Leave Block List Allow,Leave Block List Allow,Palikite Blokuoti sąrašas Leisti
apps/erpnext/erpnext/setup/doctype/company/company.py +310,Abbr can not be blank or space,Abbr negali būti tuščias arba vietos
DocType: Patient Medical Record,Patient Medical Record,Paciento medicinos ataskaita
apps/erpnext/erpnext/accounts/doctype/account/account.js +68,Group to Non-Group,Grupė ne grupės
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50,Sports,sporto
DocType: Loan Type,Loan Name,paskolos Vardas
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Actual,Iš viso Tikrasis
DocType: Lab Test UOM,Test UOM,Test UOM
DocType: Student Siblings,Student Siblings,studentų seserys
apps/erpnext/erpnext/utilities/user_progress.py +143,Unit,vienetas
apps/erpnext/erpnext/stock/get_item_details.py +136,Please specify Company,Prašome nurodyti Company
,Customer Acquisition and Loyalty,Klientų įsigijimas ir lojalumo
DocType: Asset Maintenance Task,Maintenance Task,Techninės priežiūros užduotis
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,"Sandėlis, kuriame jūs išlaikyti atsargų atmestų daiktų"
DocType: Production Order,Skip Material Transfer,Pereiti medžiagos pernešimas
DocType: Production Order,Skip Material Transfer,Pereiti medžiagos pernešimas
apps/erpnext/erpnext/setup/utils.py +109,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,"Negali rasti keitimo kursą {0}, kad {1} rakto dienos {2}. Prašome sukurti valiutos keitykla įrašą rankiniu būdu"
DocType: POS Profile,Price List,Kainoraštis
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} dabar numatytasis finansinius metus. Prašome atnaujinti savo naršyklę pakeitimas įsigaliotų.
apps/erpnext/erpnext/projects/doctype/task/task.js +45,Expense Claims,Išlaidų Pretenzijos
DocType: Issue,Support,parama
,BOM Search,BOM Paieška
DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.","Paskelbkite &quot;Sandėliuoju&quot; arba &quot;Nėra sandelyje&quot; centre, priklausomai nuo sandėlyje esančių atsargų."
DocType: Vehicle,Fuel Type,degalų tipas
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27,Please specify currency in Company,Prašome nurodyti valiutą Company
DocType: Workstation,Wages per hour,Darbo užmokestis per valandą
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},Akcijų balansas Serija {0} taps neigiamas {1} už prekę {2} į sandėlį {3}
apps/erpnext/erpnext/templates/emails/reorder_item.html +1,Following Material Requests have been raised automatically based on Item's re-order level,Šios medžiagos prašymai buvo iškeltas automatiškai pagal elemento naujo užsakymo lygio
DocType: Email Digest,Pending Sales Orders,Kol pardavimo užsakymus
apps/erpnext/erpnext/controllers/accounts_controller.py +311,Account {0} is invalid. Account Currency must be {1},Sąskaita {0} yra neteisinga. Sąskaitos valiuta turi būti {1}
DocType: Healthcare Settings,Remind Before,Prisiminti anksčiau
apps/erpnext/erpnext/buying/utils.py +34,UOM Conversion factor is required in row {0},UOM Konversijos koeficientas yra reikalaujama iš eilės {0}
DocType: Production Plan Item,material_request_item,material_request_item
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1060,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Eilutės # {0}: Informacinis dokumentas tipas turi būti vienas iš pardavimų užsakymų, pardavimo sąskaitoje-faktūroje ar žurnalo įrašą"
DocType: Salary Component,Deduction,Atskaita
DocType: Item,Retain Sample,Išsaugoti pavyzdį
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,Row {0}: From Time and To Time is mandatory.,Eilutės {0}: Nuo Laikas ir laiko yra privalomas.
DocType: Stock Reconciliation Item,Amount Difference,suma skirtumas
apps/erpnext/erpnext/stock/get_item_details.py +354,Item Price added for {0} in Price List {1},Prekė Kaina pridėta {0} kainoraštis {1}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,Prašome įvesti darbuotojo ID Šio pardavimo asmuo
DocType: Territory,Classification of Customers by region,Klasifikacija klientams regione
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71,In Production,Gamyboje
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +59,Difference Amount must be zero,Skirtumas suma turi būti lygi nuliui
DocType: Project,Gross Margin,bendroji marža
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +61,Please enter Production Item first,Prašome įvesti Gamybos Elementą pirmas
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Calculated Bank Statement balance,Apskaičiuota bankas pareiškimas balansas
DocType: Normal Test Template,Normal Test Template,Normalioji bandymo šablonas
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,neįgaliesiems vartotojas
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +913,Quotation,Pasiūlymas
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +982,Cannot set a received RFQ to No Quote,Negalima nustatyti gauta RFQ jokiai citata
DocType: Quotation,QTN-,QTN-
DocType: Salary Slip,Total Deduction,Iš viso išskaičiavimas
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +15,Select an account to print in account currency,"Pasirinkite paskyrą, kurią norite spausdinti paskyros valiuta"
,Production Analytics,gamybos Analytics &quot;
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6,This is based on transactions against this Patient. See timeline below for details,Tai pagrįsta operacijomis su šiuo pacientu. Išsamiau žr. Toliau pateiktą laiko juostą
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +201,Cost Updated,kaina Atnaujinta
DocType: Patient,Date of Birth,Gimimo data
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +129,Item {0} has already been returned,Prekė {0} jau buvo grąžinta
DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Finansiniai metai ** reiškia finansinius metus. Visi apskaitos įrašai ir kiti pagrindiniai sandoriai yra stebimi nuo ** finansiniams metams **.
DocType: Opportunity,Customer / Lead Address,Klientas / Švino Adresas
DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Tiekėjo rezultatų kortelės sąranka
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Vertinimo plano pavadinimas
apps/erpnext/erpnext/stock/doctype/item/item.py +222,Warning: Invalid SSL certificate on attachment {0},Įspėjimas: Neteisingas SSL sertifikatas nuo prisirišimo {0}
apps/erpnext/erpnext/utilities/activation.py +64,"Leads help you get business, add all your contacts and more as your leads","Laidai padėti jums gauti verslo, pridėti visus savo kontaktus ir daugiau kaip jūsų laidų"
DocType: Production Order Operation,Actual Operation Time,Tikrasis veikimo laikas
DocType: Authorization Rule,Applicable To (User),Taikoma (Vartotojas)
DocType: Purchase Taxes and Charges,Deduct,atskaityti
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236,Job Description,Darbo aprašymas
DocType: Student Applicant,Applied,taikomas
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +863,Re-open,Iš naujo atidarykite
DocType: Sales Invoice Item,Qty as per Stock UOM,Kiekis pagal vertybinių popierių UOM
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Guardian2 Vardas
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +127,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Specialūs simboliai, išskyrus &quot;-&quot;. &quot;,&quot; # &quot;, ir &quot;/&quot; neleidžiama pavadinimų seriją"
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Sekite pardavimo kampanijų. Sekite veda, citatos, pardavimų užsakymų ir tt iš kampanijų įvertinti investicijų grąžą."
DocType: Expense Claim,Approver,Tvirtintojas
,SO Qty,SO Kiekis
DocType: Guardian,Work Address,Darbovietės adresas
DocType: Appraisal,Calculate Total Score,Apskaičiuokite bendras rezultatas
DocType: Asset Repair,Manufacturing Manager,gamybos direktorius
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191,Serial No {0} is under warranty upto {1},Serijos Nr {0} yra garantija net iki {1}
DocType: Plant Analysis Criteria,Minimum Permissible Value,Mažiausias leistinas dydis
apps/erpnext/erpnext/education/doctype/guardian/guardian.py +42,User {0} already exists,Naudotojas {0} jau egzistuoja
apps/erpnext/erpnext/hooks.py +109,Shipments,vežimas
DocType: Payment Entry,Total Allocated Amount (Company Currency),Visos skirtos sumos (Įmonės valiuta)
DocType: Purchase Order Item,To be delivered to customer,Turi būti pristatytas pirkėjui
DocType: BOM,Scrap Material Cost,Laužas medžiagų sąnaudos
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227,Serial No {0} does not belong to any Warehouse,Serijos Nr {0} nepriklauso bet Warehouse
DocType: Grant Application,Email Notification Sent,Siunčiamas pranešimas el. Paštu
DocType: Purchase Invoice,In Words (Company Currency),Žodžiais (Įmonės valiuta)
DocType: Pricing Rule,Supplier,tiekėjas
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41,Show Payment Details,Rodyti mokėjimo informaciją
DocType: Consultation,Consultation Time,Konsultacijos laikas
DocType: C-Form,Quarter,ketvirtis
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Miscellaneous Expenses,Įvairūs išlaidos
DocType: Global Defaults,Default Company,numatytasis Įmonės
apps/erpnext/erpnext/controllers/stock_controller.py +227,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Kompensuojamos ar Skirtumas sąskaitos yra privalomas punktas {0} kaip ji įtakoja bendra akcijų vertė
DocType: Payment Request,PR,PR
DocType: Cheque Print Template,Bank Name,Banko pavadinimas
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +29,-Above,-Above
DocType: Employee Loan,Employee Loan Account,Darbuotojų Paskolos paskyra
DocType: Leave Application,Total Leave Days,Iš viso nedarbingumo dienų
DocType: Email Digest,Note: Email will not be sent to disabled users,Pastaba: elektroninio pašto adresas nebus siunčiami neįgaliems vartotojams
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Taškų sąveika
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Taškų sąveika
apps/erpnext/erpnext/stock/doctype/item/item.js +105,Item Variant Settings,Elemento variantų nustatymai
apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +39,Select Company...,Pasirinkite bendrovė ...
DocType: Leave Control Panel,Leave blank if considered for all departments,"Palikite tuščią, jei manoma, skirtų visiems departamentams"
apps/erpnext/erpnext/config/hr.py +228,"Types of employment (permanent, contract, intern etc.).","Tipai darbo (nuolatinis, sutarčių, vidaus ir kt.)"
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +421,{0} is mandatory for Item {1},{0} yra privalomas punktas {1}
DocType: Payroll Entry,Fortnightly,kas dvi savaitės
DocType: Currency Exchange,From Currency,nuo valiuta
DocType: Vital Signs,Weight (In Kilogram),Svoris (kilogramais)
DocType: Chapter,"chapters/chapter_name
leave blank automatically set after saving chapter.",skyrius / chapter_name palikti tuščią automatiškai nustatyti po išsaugojimo skyriuje.
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +169,Please set GST Accounts in GST Settings,Nustatykite GST paskyras
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +31,Type of Business,Verslo tipas
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +170,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Prašome pasirinkti skirtos sumos, sąskaitos faktūros tipas ir sąskaitos numerį atleast vienoje eilėje"
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128,Cost of New Purchase,Kaina New pirkimas
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97,Sales Order required for Item {0},Pardavimų užsakymų reikalingas punktas {0}
DocType: Grant Application,Grant Description,Pareiškimo aprašas
DocType: Purchase Invoice Item,Rate (Company Currency),Norma (Įmonės valiuta)
DocType: Student Guardian,Others,kiti
DocType: Payment Entry,Unallocated Amount,Nepaskirstytas kiekis
apps/erpnext/erpnext/templates/includes/product_page.js +71,Cannot find a matching Item. Please select some other value for {0}.,Nerandate atitikimo elementą. Prašome pasirinkti kokią nors kitą vertę {0}.
DocType: POS Profile,Taxes and Charges,Mokesčiai ir rinkliavos
DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Produktas arba paslauga, kuri yra perkama, parduodama arba laikomi sandėlyje."
apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44,No more updates,Ne daugiau atnaujinimai
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Negalima pasirinkti įkrovimo tipas, kaip &quot;Dėl ankstesnės eilės Suma&quot; arba &quot;Dėl ankstesnės eilės Total&quot; už pirmoje eilutėje"
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6,This covers all scorecards tied to this Setup,"Tai apima visas rezultatų korteles, susietas su šia sąranka"
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,Vaikų punktas neturėtų būti Prekės paketas. Prašome pašalinti elementą `{0}` ir sutaupyti
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12,Banking,bankinis
apps/erpnext/erpnext/utilities/activation.py +108,Add Timesheets,Įdėti laiko apskaitos žiniaraščiai
DocType: Vehicle Service,Service Item,Paslaugų punktas
DocType: Bank Guarantee,Bank Guarantee,Banko garantija
DocType: Bank Guarantee,Bank Guarantee,Banko garantija
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,Prašome spausti &quot;Generuoti grafiką&quot; gauti tvarkaraštį
DocType: Bin,Ordered Quantity,Užsakytas Kiekis
apps/erpnext/erpnext/public/js/setup_wizard.js +118,"e.g. ""Build tools for builders""",pvz &quot;Build įrankiai statybininkai&quot;
DocType: Grading Scale,Grading Scale Intervals,Vertinimo skalė intervalai
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: apskaitos įrašas už {2} galima tik valiuta: {3}
DocType: Fee Schedule,In Process,Procese
DocType: Authorization Rule,Itemwise Discount,Itemwise nuolaida
apps/erpnext/erpnext/config/accounts.py +75,Tree of financial accounts.,Medis finansines ataskaitas.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +362,{0} against Sales Order {1},{0} prieš Pardavimų ordino {1}
DocType: Account,Fixed Asset,Ilgalaikio turto
apps/erpnext/erpnext/config/stock.py +320,Serialized Inventory,Serijinis Inventorius
DocType: Employee Loan,Account Info,Sąskaitos info
DocType: Activity Type,Default Billing Rate,Numatytasis Atsiskaitymo Balsuok
DocType: Fees,Include Payment,Įtraukti mokėjimą
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} Studentų grupės sukurtas.
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} Studentų grupės sukurtas.
DocType: Sales Invoice,Total Billing Amount,Iš viso Atsiskaitymo suma
apps/erpnext/erpnext/hr/doctype/daily_work_summary_settings/daily_work_summary_settings.py +17,There must be a default incoming Email Account enabled for this to work. Please setup a default incoming Email Account (POP/IMAP) and try again.,Turi būti numatytasis Priimamojo pašto dėžutę leido šį darbą. Prašome setup numatytąją Priimamojo pašto dėžutę (POP / IMAP) ir bandykite dar kartą.
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50,Program in the Fee Structure and Student Group {0} are different.,Mokesčių struktūros ir studentų grupės {0} programos skiriasi.
DocType: Fee Schedule,Receivable Account,gautinos sąskaitos
apps/erpnext/erpnext/controllers/accounts_controller.py +617,Row #{0}: Asset {1} is already {2},Eilutės # {0}: Turto {1} jau yra {2}
DocType: Quotation Item,Stock Balance,akcijų balansas
apps/erpnext/erpnext/config/selling.py +316,Sales Order to Payment,"Pardavimų užsakymų, kad mokėjimo"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123,CEO,Vadovas
DocType: Purchase Invoice,With Payment of Tax,Mokesčio mokėjimas
DocType: Expense Claim Detail,Expense Claim Detail,Kompensuojamos Pretenzija detalės
DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,Trimis egzemplioriais tiekėjas
DocType: Land Unit,Is Container,Yra konteineris
DocType: Crop Cycle,This will be day 1 of the crop cycle,Tai bus pirmoji derliaus ciklo diena
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +869,Please select correct account,Prašome pasirinkti tinkamą sąskaitą
DocType: Purchase Invoice Item,Weight UOM,Svoris UOM
DocType: Salary Structure Employee,Salary Structure Employee,"Darbo užmokesčio struktūrą, darbuotojų"
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45,Show Variant Attributes,Rodyti variantų savybes
DocType: Student,Blood Group,Kraujo grupė
DocType: Course,Course Name,Kurso pavadinimas
DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,"Vartotojai, kurie gali patvirtinti konkretaus darbuotojo atostogų prašymus"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52,Office Equipments,Biuro įranga
DocType: Purchase Invoice Item,Qty,Kiekis
DocType: Fiscal Year,Companies,įmonės
DocType: Supplier Scorecard,Scoring Setup,Balų nustatymas
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,elektronika
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Pakelkite Material užklausą Kai akcijų pasiekia naujo užsakymo lygį
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98,Full-time,Pilnas laikas
DocType: Payroll Entry,Employees,darbuotojai
DocType: Employee,Contact Details,Kontaktiniai duomenys
DocType: C-Form,Received Date,gavo data
DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Jei sukūrėte standartinį šabloną pardavimo mokesčius bei rinkliavas ruošiniu, pasirinkite vieną ir spauskite žemiau esantį mygtuką."
DocType: BOM Scrap Item,Basic Amount (Company Currency),Pagrindinė suma (Įmonės valiuta)
DocType: Student,Guardians,globėjai
DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,"Kainos nebus rodomas, jei Kainų sąrašas nenustatytas"
DocType: Stock Entry,Total Incoming Value,Iš viso Priimamojo Vertė
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +349,Debit To is required,Debeto reikalingas
apps/erpnext/erpnext/utilities/activation.py +109,"Timesheets help keep track of time, cost and billing for activites done by your team","Laiko apskaitos žiniaraščiai padėti sekti laiko, išlaidų ir sąskaitų už veiklose padaryti jūsų komanda"
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Pirkimo Kainų sąrašas
apps/erpnext/erpnext/config/buying.py +155,Templates of supplier scorecard variables.,Tiekimo rezultatų kortelės kintamųjų šablonai.
DocType: Offer Letter Term,Offer Term,Siūlau terminas
DocType: Asset,Quality Manager,Kokybės vadybininkas
DocType: Job Applicant,Job Opening,darbo skelbimai
DocType: Payment Reconciliation,Payment Reconciliation,Mokėjimo suderinimas
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153,Please select Incharge Person's name,Prašome pasirinkti Incharge Asmens vardas
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51,Technology,technologija
DocType: Hub Settings,Unregister from Hub,Išregistruoti iš &quot;Hub&quot;
apps/erpnext/erpnext/public/js/utils.js +102,Total Unpaid: {0},Iš viso nesumokėtas: {0}
DocType: BOM Website Operation,BOM Website Operation,BOM svetainė Operacija
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,Offer Letter,laiško su pasiūlymu
apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Production Orders.,Sukurti Materialieji prašymų (MRP) ir gamybos užsakymus.
DocType: Supplier Scorecard,Supplier Score,Tiekėjo balas
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +87,Total Invoiced Amt,Viso į sąskaitas įtraukto Amt
DocType: Supplier,Warn RFQs,Perspėti RFQ
DocType: BOM,Conversion Rate,Perskaičiavimo kursas
apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Prekės paieška
DocType: Assessment Plan,To Time,laiko
DocType: Authorization Rule,Approving Role (above authorized value),Patvirtinimo vaidmenį (virš įgalioto vertės)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118,Credit To account must be a Payable account,Kreditas sąskaitos turi būti mokėtinos sąskaitos
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,"Prašome pasirinkti Studentų priėmimą, kuris yra privalomas mokamam studento pareiškėjui"
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +338,BOM recursion: {0} cannot be parent or child of {2},BOM rekursija: {0} negali būti tėvų ar vaikas {2}
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +23,Please select a Price List to publish pricing,"Pasirinkite kainoraštį, kad paskelbtumėte kainodarą"
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38,Budget List,Biudžeto sąrašas
DocType: Production Order Operation,Completed Qty,užbaigtas Kiekis
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +146,"For {0}, only debit accounts can be linked against another credit entry","Dėl {0}, tik debeto sąskaitos gali būti susijęs su kitos kredito įrašą"
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27,Price List {0} is disabled,Kainų sąrašas {0} yra išjungtas
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127,Row {0}: Completed Qty cannot be more than {1} for operation {2},Eilutės {0}: baigė Kiekis gali būti ne daugiau kaip {1} darbui {2}
DocType: Manufacturing Settings,Allow Overtime,Leiskite viršvalandžius
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serijinis {0} Prekė negali būti atnaujintas naudojant Inventorinis susitaikymo, prašome naudoti Inventorinis įrašą"
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serijinis {0} Prekė negali būti atnaujintas naudojant Inventorinis susitaikymo, prašome naudoti Inventorinis įrašą"
DocType: Training Event Employee,Training Event Employee,Mokymai Renginių Darbuotojų
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1009,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Maksimalūs mėginiai - {0} gali būti laikomi paketui {1} ir vienetui {2}.
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +6,Add Time Slots,Pridėti laiko laiko tarpsnius
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Serial numeriai reikalingi punkte {1}. Jūs sąlyga {2}.
DocType: Stock Reconciliation Item,Current Valuation Rate,Dabartinis vertinimas Balsuok
DocType: Item,Customer Item Codes,Klientų punktas kodai
DocType: Training Event,Advance,Iš anksto
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,for making recurring again.,dar kartą pasikartoti.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122,Exchange Gain/Loss,Valiutų Pelnas / nuostolis
DocType: Opportunity,Lost Reason,Pamiršote Priežastis
apps/erpnext/erpnext/controllers/accounts_controller.py +264,Row #{0}: Account {1} does not belong to company {2},Eilutė # {0}: sąskaita {1} nepriklauso bendrovei {2}
apps/erpnext/erpnext/public/js/templates/address_list.html +22,New Address,Naujas adresas
DocType: Quality Inspection,Sample Size,imties dydis
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47,Please enter Receipt Document,Prašome įvesti Gavimas dokumentą
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +369,All items have already been invoiced,Visos prekės jau išrašyta sąskaita
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49,Please specify a valid 'From Case No.',Nurodykite tinkamą &quot;Nuo byloje Nr &#39;
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,"Daugiau kaštų centrai gali būti grupėse, tačiau įrašai gali būti pareikštas ne grupės"
apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Vartotojai ir leidimai
DocType: Vehicle Log,VLOG.,Vlog.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +994,Production Orders Created: {0},Gamybos užsakymų Sukurta: {0}
DocType: Branch,Branch,filialas
DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
DocType: Delivery Trip,Fulfillment User,Įvykdymo naudotojas
apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Spausdinimo ir paviljonai
DocType: Company,Total Monthly Sales,Bendras mėnesinis pardavimas
DocType: Agriculture Analysis Criteria,Weather,Orai
DocType: Bin,Actual Quantity,Tikrasis Kiekis
DocType: Shipping Rule,example: Next Day Shipping,Pavyzdys: Sekanti diena Pristatymas
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187,Serial No {0} not found,Serijos Nr {0} nerastas
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +289,Subscription has been {0},Prenumerata buvo {0}
DocType: Fee Schedule Program,Fee Schedule Program,Mokesčių tvarkaraščio programa
DocType: Fee Schedule Program,Student Batch,Studentų Serija
apps/erpnext/erpnext/utilities/activation.py +119,Make Student,Padaryti Studentas
DocType: Supplier Scorecard Scoring Standing,Min Grade,Min. Kategorija
apps/erpnext/erpnext/projects/doctype/project/project.py +214,You have been invited to collaborate on the project: {0},Jūs buvote pakviestas bendradarbiauti su projektu: {0}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107,Physician not available on {0},Gydytojas nėra {0}
DocType: Leave Block List Date,Block Date,Blokuoti data
DocType: Crop,Crop,Apkarpyti
DocType: Purchase Receipt,Supplier Delivery Note,Tiekėjo pristatymo pastaba
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70,Apply Now,taikyti Dabar
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Faktinis Kiekis {0} / laukimo Kiekis {1}
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Faktinis Kiekis {0} / laukimo Kiekis {1}
DocType: Purchase Invoice,E-commerce GSTIN,E-komercija GSTIN
DocType: Sales Order,Not Delivered,Nepristatytas
,Bank Clearance Summary,Bankas Sąskaitų santrauka
apps/erpnext/erpnext/config/setup.py +106,"Create and manage daily, weekly and monthly email digests.","Kurkite ir tvarkykite savo dienos, savaitės ir mėnesio el suskaldyti."
DocType: Appraisal Goal,Appraisal Goal,vertinimas tikslas
DocType: Stock Reconciliation Item,Current Amount,Dabartinis suma
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58,Buildings,Pastatai
DocType: Fee Schedule,Fee Structure,mokestis struktūra
DocType: Timesheet Detail,Costing Amount,Sąnaudų dydis
DocType: Student Admission Program,Application Fee,Paraiškos mokestis
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +50,Submit Salary Slip,Pateikti darbo užmokestį
apps/erpnext/erpnext/controllers/selling_controller.py +136,Maxiumm discount for Item {0} is {1}%,Maxiumm nuolaida Prekės {0} yra {1}%
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Importas į taros
DocType: Sales Partner,Address & Contacts,Adresas ir kontaktai
DocType: SMS Log,Sender Name,siuntėjas Vardas
DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Žemės ūkio analizės kriterijai
apps/erpnext/erpnext/hub_node/page/hub/hub.js +193,Sort by Criteria,Rūšiuoti pagal kriterijus
DocType: POS Profile,[Select],[Pasirinkti]
DocType: Vital Signs,Blood Pressure (diastolic),Kraujo spaudimas (diastolinis)
DocType: SMS Log,Sent To,Siunčiami į
DocType: Agriculture Task,Holiday Management,Atostogų valdymas
DocType: Payment Request,Make Sales Invoice,Padaryti pardavimo sąskaita-faktūra
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61,Softwares,Programinė įranga
apps/erpnext/erpnext/crm/doctype/lead/lead.py +51,Next Contact Date cannot be in the past,Kitas Kontaktinė data negali būti praeityje
DocType: Company,For Reference Only.,Tik nuoroda.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +99,Physician {0} not available on {1},Gydytojas {0} negalimas {1}
apps/erpnext/erpnext/accounts/page/pos/pos.js +2539,Select Batch No,Pasirinkite Serija Nėra
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +57,Invalid {0}: {1},Neteisingas {0}: {1}
,GSTR-1,GSTR-1
DocType: Purchase Invoice,PINV-RET-,PINV-RET-
DocType: Fee Validity,Reference Inv,Informacinė investicija
DocType: Sales Invoice Advance,Advance Amount,avanso suma
DocType: Manufacturing Settings,Capacity Planning,Talpa planavimas
DocType: Supplier Quotation,Rounding Adjustment (Company Currency,Apvalinimo koregavimas (įmonės valiuta
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43,'From Date' is required,&quot;Nuo data&quot; reikalingas
DocType: Journal Entry,Reference Number,Šaltinio numeris
DocType: Employee,Employment Details,įdarbinimo detalės
DocType: Employee,New Workplace,nauja Darbo
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Nustatyti kaip Uždarymo
apps/erpnext/erpnext/stock/get_item_details.py +125,No Item with Barcode {0},Nėra Prekė su Brūkšninis kodas {0}
DocType: Normal Test Items,Require Result Value,Reikalauti rezultato vertės
DocType: Item,Show a slideshow at the top of the page,Rodyti skaidrių peržiūrą į puslapio viršuje
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +517,Boms,Boms
apps/erpnext/erpnext/stock/doctype/item/item.py +151,Stores,parduotuvės
DocType: Project Type,Projects Manager,Projektų vadovas
DocType: Serial No,Delivery Time,Pristatymo laikas
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,Senėjimo remiantis
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +66,Appointment cancelled,Paskyrimas atšauktas
DocType: Item,End of Life,Gyvenimo pabaiga
apps/erpnext/erpnext/demo/setup/setup_data.py +331,Travel,Kelionė
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +182,No active or default Salary Structure found for employee {0} for the given dates,Nėra aktyvus arba numatytąjį darbo užmokesčio struktūrą ir darbuotojo {0} nerasta pagal nurodytą datą
DocType: Leave Block List,Allow Users,leisti vartotojams
DocType: Purchase Order,Customer Mobile No,Klientų Mobilus Nėra
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1,Recurring,pasikartojančios
DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Sekti atskirą pajamos ir išlaidos už produktų segmentus ar padalinių.
DocType: Rename Tool,Rename Tool,pervadinti įrankis
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72,Update Cost,Atnaujinti Kaina
DocType: Item Reorder,Item Reorder,Prekė Pertvarkyti
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463,Show Salary Slip,Rodyti Pajamos Kuponas
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +848,Transfer Material,perduoti medžiagą
DocType: Fees,Send Payment Request,Siųsti mokėjimo užklausą
DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Nurodykite operacijas, veiklos sąnaudas ir suteikti unikalią eksploatuoti ne savo operacijas."
DocType: Water Analysis,Origin,Kilmė
apps/erpnext/erpnext/controllers/status_updater.py +201,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Šis dokumentas yra virš ribos iki {0} {1} už prekę {4}. Darai dar {3} prieš patį {2}?
apps/erpnext/erpnext/public/js/controllers/transaction.js +1142,Please set recurring after saving,Prašome nustatyti pasikartojančių po taupymo
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +756,Select change amount account,Pasirinkite Keisti suma sąskaita
DocType: Purchase Invoice,Price List Currency,Kainų sąrašas Valiuta
DocType: Naming Series,User must always select,Vartotojas visada turi pasirinkti
DocType: Stock Settings,Allow Negative Stock,Leiskite Neigiama Stock
DocType: Installation Note,Installation Note,Įrengimas Pastaba
DocType: Soil Texture,Clay,Molis
DocType: Topic,Topic,tema
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +40,Cash Flow from Financing,Pinigų srautai iš finansavimo
DocType: Budget Account,Budget Account,biudžeto sąskaita
DocType: Quality Inspection,Verified By,Patvirtinta
apps/erpnext/erpnext/setup/doctype/company/company.py +77,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Nepavyksta pakeisti įmonės numatytasis valiuta, nes yra esami sandoriai. Sandoriai turi būti atšauktas pakeisti numatytasis valiuta."
DocType: Grading Scale Interval,Grade Description,Įvertinimas Aprašymas
DocType: Stock Entry,Purchase Receipt No,Pirkimo kvito Ne
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,rimtai Pinigai
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,atsekamumas
DocType: Asset Maintenance Log,Actions performed,Veiksmai atlikti
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137,Source of Funds (Liabilities),Lėšų šaltinis (įsipareigojimai)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +411,Quantity in row {0} ({1}) must be same as manufactured quantity {2},"Kiekis eilės {0} ({1}) turi būti toks pat, kaip gaminamo kiekio {2}"
DocType: Supplier Scorecard Scoring Standing,Employee,Darbuotojas
DocType: Asset Repair,Failure Date,Gedimo data
DocType: Sample Collection,Collected Time,Surinktas laikas
apps/erpnext/erpnext/config/healthcare.py +134,Test Sample.,Bandymo pavyzdys.
DocType: Company,Sales Monthly History,Pardavimų mėnesio istorija
DocType: Asset Maintenance Task,Next Due Date,Kitas terminas
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214,Select Batch,Pasirinkite Serija
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +242,{0} {1} is fully billed,{0} {1} yra pilnai mokami
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +47,Vital Signs,Gyvybės ženklai
DocType: Training Event,End Time,pabaigos laikas
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,Active Salary Structure {0} found for employee {1} for the given dates,Aktyvus darbo užmokesčio struktūrą {0} darbuotojo {1} rasta pateiktų datų
DocType: Payment Entry,Payment Deductions or Loss,Apmokėjimo Atskaitymai arba nuostolis
DocType: Soil Analysis,Soil Analysis Criterias,Dirvožemio analizės kriterijai
apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Standartinės sutarčių sąlygos pardavimo ar pirkimo.
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +100,Group by Voucher,Grupė kuponą
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +195,Are you sure you want to cancel this appointment?,Ar tikrai norite atšaukti šį susitikimą?
apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,pardavimų vamzdynų
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201,Please set default account in Salary Component {0},Prašome nustatyti numatytąją sąskaitą užmokesčių Component {0}
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Reikalinga Apie
DocType: Rename Tool,File to Rename,Failo pervadinti
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200,Please select BOM for Item in Row {0},Prašome pasirinkti BOM už prekę eilutėje {0}
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account {0} does not match with Company {1} in Mode of Account: {2},Sąskaita {0} nesutampa su kompanija {1} iš sąskaitos būdas: {2}
apps/erpnext/erpnext/controllers/buying_controller.py +289,Specified BOM {0} does not exist for Item {1},Neapibūdintas BOM {0} neegzistuoja punkte {1}
DocType: Soil Texture,Sandy Loam,Sandy Loam
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Priežiūros planas {0} turi būti atšauktas prieš panaikinant šį pardavimo užsakymų
DocType: POS Profile,Applicable for Users,Taikoma naudotojams
DocType: Notification Control,Expense Claim Approved,Kompensuojamos Pretenzija Patvirtinta
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321,Salary Slip of employee {0} already created for this period,Pajamos Kuponas darbuotojo {0} jau sukurta per šį laikotarpį
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155,Pharmaceutical,Farmacijos
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Kaina įsigytų daiktų
DocType: Selling Settings,Sales Order Required,Pardavimų užsakymų Reikalinga
DocType: Purchase Invoice,Credit To,Kreditas
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31,Active Leads / Customers,Aktyvios laidai / Klientai
DocType: Employee Education,Post Graduate,Doktorantas
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Priežiūros planas Išsamiau
DocType: Supplier Scorecard,Warn for new Purchase Orders,Įspėti apie naujus pirkimo užsakymus
DocType: Quality Inspection Reading,Reading 9,Skaitymas 9
DocType: Supplier,Is Frozen,Ar Sušaldyti
apps/erpnext/erpnext/stock/utils.py +221,Group node warehouse is not allowed to select for transactions,Grupė mazgas sandėlis neleidžiama pasirinkti sandorius
DocType: Buying Settings,Buying Settings,Ieško Nustatymai
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,"BOM Nr Dėl gatavo geras straipsnis,"
DocType: Upload Attendance,Attendance To Date,Dalyvavimas data
DocType: Request for Quotation Supplier,No Quote,Nr citatos
DocType: Warranty Claim,Raised By,Užaugino
DocType: Payment Gateway Account,Payment Account,Mokėjimo sąskaita
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +906,Please specify Company to proceed,Prašome nurodyti Bendrovei toliau
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +22,Net Change in Accounts Receivable,Grynasis pokytis gautinos
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88,Compensatory Off,kompensacinė Išjungtas
DocType: Offer Letter,Accepted,priimtas
DocType: Grant Application,Organization,organizacija
DocType: Grant Application,Organization,organizacija
DocType: BOM Update Tool,BOM Update Tool,BOM naujinimo įrankis
DocType: SG Creation Tool Course,Student Group Name,Studentų Grupės pavadinimas
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js +17,Show exploded view,Rodyti išskaidytą vaizdą
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Mokesčių kūrimas
apps/erpnext/erpnext/setup/doctype/company/company.js +91,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,"Prašome įsitikinkite, kad jūs tikrai norite ištrinti visus šios bendrovės sandorius. Jūsų pagrindiniai duomenys liks kaip ji yra. Šis veiksmas negali būti atšauktas."
DocType: Room,Room Number,Kambario numeris
apps/erpnext/erpnext/utilities/transaction_base.py +101,Invalid reference {0} {1},Neteisingas nuoroda {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}) negali būti didesnis nei planuota quanitity ({2}) Gamybos Užsakyti {3}
DocType: Shipping Rule,Shipping Rule Label,Pristatymas taisyklė Etiketė
DocType: Journal Entry Account,Payroll Entry,Darbo užmokesčio įrašas
apps/erpnext/erpnext/setup/doctype/company/company.js +35,Make Tax Template,Padaryti mokesčių šabloną
apps/erpnext/erpnext/public/js/conf.js +28,User Forum,vartotojas Forumas
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +308,Raw Materials cannot be blank.,Žaliavos negali būti tuščias.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +485,"Could not update stock, invoice contains drop shipping item.","Nepavyko atnaujinti atsargų, sąskaitos faktūros yra lašas laivybos elementą."
DocType: Lab Test Sample,Lab Test Sample,Laboratorinio bandinio pavyzdys
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +492,Quick Journal Entry,Greita leidinys įrašas
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200,You can not change rate if BOM mentioned agianst any item,"Jūs negalite keisti greitį, jei BOM minėta agianst bet kurį elementą"
DocType: Restaurant,Invoice Series Prefix,Sąskaitų serijos prefiksas
DocType: Employee,Previous Work Experience,Ankstesnis Darbo patirtis
DocType: Stock Entry,For Quantity,dėl Kiekis
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205,Please enter Planned Qty for Item {0} at row {1},Prašome įvesti planuojama Kiekis už prekę {0} ne eilės {1}
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +102,Google Maps integration is not enabled,&quot;Google&quot; žemėlapių integracija nėra įjungta
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +239,{0} {1} is not submitted,{0} {1} nebus pateiktas
DocType: Production Planning Tool,Separate production order will be created for each finished good item.,Atskirų gamybos užsakymas bus sukurtas kiekvienos gatavo gero prekę nėra.
DocType: Member,Membership Expiry Date,Narystės galiojimo data
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +127,{0} must be negative in return document,{0} turi būti neigiama grąžinimo dokumentą
,Minutes to First Response for Issues,Minučių iki Pirmosios atsakas klausimai
DocType: Purchase Invoice,Terms and Conditions1,Taisyklės ir sąlygų1
apps/erpnext/erpnext/public/js/setup_wizard.js +109,The name of the institute for which you are setting up this system.,"Instituto pavadinimas, kurį nustatote šią sistemą."
DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Apskaitos įrašas, užšaldyti iki šios datos, niekas negali padaryti / pakeisti įrašą, išskyrus žemiau nurodytą vaidmenį."
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116,Please save the document before generating maintenance schedule,Prašome įrašyti dokumentą prieš generuoti priežiūros tvarkaraštį
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30,Latest price updated in all BOMs,Paskutinė kaina atnaujinta visose BOM
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,projekto statusas
DocType: UOM,Check this to disallow fractions. (for Nos),Pažymėkite tai norėdami atmesti frakcijas. (Už Nr)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +424,The following Production Orders were created:,Buvo sukurtos naujos gamybos užsakymų:
DocType: Student Admission Program,Naming Series (for Student Applicant),Pavadinimų serija (Studentų pareiškėjas)
DocType: Delivery Note,Transporter Name,Vežėjas pavadinimas
DocType: Authorization Rule,Authorized Value,įgaliotas Vertė
DocType: BOM,Show Operations,Rodyti operacijos
,Minutes to First Response for Opportunity,Minučių iki Pirmosios atsakas Opportunity
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Absent,Iš viso Nėra
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +840,Item or Warehouse for row {0} does not match Material Request,Punktas arba sandėlis eilės {0} nesutampa Medžiaga Užsisakyti
apps/erpnext/erpnext/config/stock.py +187,Unit of Measure,Matavimo vienetas
DocType: Fiscal Year,Year End Date,Dienos iki metų pabaigos
DocType: Task Depends On,Task Depends On,Užduotis Priklauso nuo
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1024,Opportunity,galimybė
,Completed Production Orders,Užbaigtos gamybos užsakymus
DocType: Operation,Default Workstation,numatytasis Workstation
DocType: Notification Control,Expense Claim Approved Message,Kompensuojamos Pretenzija Patvirtinta pranešimas
DocType: Payment Entry,Deductions or Loss,Atskaitymai arba nuostolis
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +245,{0} {1} is closed,{0} {1} yra uždarytas
DocType: Email Digest,How frequently?,Kaip dažnai?
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +58,Total Collected: {0},Iš viso surinkta: {0}
DocType: Purchase Receipt,Get Current Stock,Gauk Current Stock
apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Medis bilis medžiagos
DocType: Student,Joining Date,Prisijungimas data
,Employees working on a holiday,"Darbuotojai, dirbantys atostogų"
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Pažymėti dabartis
DocType: Project,% Complete Method,% Visiškas būdas
apps/erpnext/erpnext/healthcare/setup.py +181,Drug,Narkotikai
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200,Maintenance start date can not be before delivery date for Serial No {0},Priežiūra pradžios data negali būti iki pristatymo datos Serijos Nr {0}
DocType: Production Order,Actual End Date,Tikrasis Pabaigos data
DocType: BOM,Operating Cost (Company Currency),Operacinė Kaina (Įmonės valiuta)
DocType: Purchase Invoice,PINV-,PINV-
DocType: Authorization Rule,Applicable To (Role),Taikoma (vaidmenų)
DocType: BOM Update Tool,Replace BOM,Pakeiskite BOM
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110,Code {0} already exist,Kodas {0} jau egzistuoja
DocType: Employee Advance,Purpose,tikslas
DocType: Company,Fixed Asset Depreciation Settings,Ilgalaikio turto nusidėvėjimo Nustatymai
DocType: Item,Will also apply for variants unless overrridden,Bus taikoma variantų nebent overrridden
DocType: Purchase Invoice,Advances,avansai
DocType: Production Order,Manufacture against Material Request,Gamyba prieš Medžiaga Užsisakyti
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +10,Assessment Group: ,Vertinimo grupė:
DocType: Item Reorder,Request for,prašymas
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,Patvirtinimo vartotoją negali būti tas pats kaip vartotojas taisyklė yra taikoma
DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Bazinis tarifas (pagal vertybinių popierių UOM)
DocType: SMS Log,No of Requested SMS,Ne prašomosios SMS
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +245,Leave Without Pay does not match with approved Leave Application records,Palikite be darbo užmokesčio nesutampa su patvirtintais prašymo suteikti atostogas įrašų
DocType: Campaign,Campaign-.####,Kampanija-.####
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Tolesni žingsniai
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +794,Please supply the specified items at the best possible rates,Prašome pateikti nurodytus elementus ne į geriausias įmanomas normas
DocType: Membership,USD,USD
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Make Invoice,Padaryti sąskaitą faktūrą
DocType: Selling Settings,Auto close Opportunity after 15 days,Auto arti Galimybė po 15 dienų
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +82,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,"Įsigijimo užsakymai neleidžiami {0} dėl rodiklio, kuris yra {1}."
apps/erpnext/erpnext/public/js/financial_statements.js +83,End Year,pabaigos metai
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Quot / Švinas%
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Quot / Švinas%
apps/erpnext/erpnext/hr/doctype/employee/employee.py +124,Contract End Date must be greater than Date of Joining,Sutarties pabaigos data turi būti didesnis nei įstoti data
DocType: Driver,Driver,Vairuotojas
DocType: Vital Signs,Nutrition Values,Mitybos vertės
DocType: Lab Test Template,Is billable,Apmokestinamas
DocType: Delivery Note,DN-,DN-
apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +44,"Both ""Physician Schedule"" and Time Per Appointment"" must be set for Dr {0}",Reikia nustatyti Dr. {0} &quot;Gydytojų tvarkaraštis&quot; ir &quot;Laikas per susitikimą&quot;
DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,"Trečioji šalis Platintojas / atstovas / Komisijos atstovas / filialo / perpardavinėtojas, kuris parduoda bendrovių produktus komisija."
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +374,{0} against Purchase Order {1},{0} prieš Užsakymo {1}
DocType: Patient,Patient Demographics,Paciento demografija
DocType: Task,Actual Start Date (via Time Sheet),Tikrasis pradžios data (per Time lapas)
apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15,This is an example website auto-generated from ERPNext,"Tai yra pavyzdys, svetainė Automatiškai sugeneruota iš ERPNext"
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +37,Ageing Range 1,Senėjimas klasės 1
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +226,Total advance amount cannot be greater than total claimed amount,Bendra išankstinė suma negali būti didesnė už visą reikalaujamą sumą
DocType: Purchase Taxes and Charges Template,"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.

#### Note

The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.
10. Add or Deduct: Whether you want to add or deduct the tax.","Standartinė mokestis šablonas, kuris gali būti taikomas visiems pirkimo sandorių. Šis šablonas gali būti sąrašą mokesčių vadovų, taip pat kito sąskaita vadovams, pavyzdžiui, &quot;Pristatymas&quot;, &quot;Draudimas&quot;, &quot;tvarkymas&quot; ir tt #### Pastaba mokesčio tarifas, kurį nurodote čia bus standartinis mokesčio tarifas visiems ** daiktai * *. Jei yra ** daiktai **, kurios turi skirtingus tarifus, jie turi būti pridėta ** Prekės mokesčio ** lentelę ** Prekės ** meistras. #### Aprašymas Stulpeliai 1. Skaičiavimo tipas: - Tai gali būti ** Grynasis Viso ** (tai yra bazinio dydžio suma). - ** Dėl ankstesnės eilės viso / suma ** (kumuliacinį mokesčius ar rinkliavas). Jei pasirinksite šią parinktį, mokestis bus taikomas kaip ankstesnės eilės procentais (mokesčių lentelę) sumos arba iš viso. - ** Tikrasis ** (kaip minėta). 2. Sąskaitos vadovas: Sąskaitos knygos, pagal kurią šis mokestis bus nubaustas 3. Sąnaudų centras: Jei mokestis / mokestis yra pajamų (pavyzdžiui, laivybos) arba išlaidų ji turi būti nubaustas nuo išlaidų centro. 4. Aprašymas: Aprašymas mokesčio (kuris bus spausdinamas sąskaitų faktūrų / kabučių). 5. Vertinti: Mokesčio tarifas. 6. Suma: Mokesčių suma. 7. Iš viso: Kaupiamasis viso šio taško. 8. Įveskite Row: Jei remiantis &quot;ankstesnės eilės viso&quot; galite pasirinkti numerį eilutės, kurios bus imtasi kaip pagrindą šiam apskaičiavimui (pagal nutylėjimą yra ankstesnė eilutė). 9. Apsvarstykite mokestį arba rinkliavą už: Šiame skyriuje galite nurodyti, ar mokestis / mokestis yra tik vertinimo (ne iš visų dalis) arba tik iš viso (neprideda vertės punkte) arba abu. 10. Pridėti arba atimama: Nesvarbu, ar norite įtraukti arba atskaičiuoti mokestį."
DocType: Homepage,Homepage,Pagrindinis puslapis
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +71,Select Physician...,Pasirinkite gydytoją ...
DocType: Grant Application,Grant Application Details ,Pareiškimo detalės
DocType: Purchase Receipt Item,Recd Quantity,Recd Kiekis
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +65,Fee Records Created - {0},Fee Įrašai Sukurta - {0}
DocType: Asset Category Account,Asset Category Account,Turto Kategorija paskyra
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +137,Cannot produce more Item {0} than Sales Order quantity {1},Negali gaminti daugiau Elementą {0} nei pardavimų užsakymų kiekio {1}
apps/erpnext/erpnext/stock/doctype/item/item.js +360,Select Attribute Values,Pasirinkite atributo reikšmes
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +537,Stock Entry {0} is not submitted,"Atsargų, {0} nebus pateiktas"
DocType: Payment Reconciliation,Bank / Cash Account,Bankas / Pinigų paskyra
apps/erpnext/erpnext/crm/doctype/lead/lead.py +45,Next Contact By cannot be same as the Lead Email Address,"Kitas Susisiekti negali būti toks pat, kaip pagrindiniam pašto adresas"
DocType: Tax Rule,Billing City,atsiskaitymo Miestas
DocType: Asset,Manual,vadovas
DocType: Salary Component Account,Salary Component Account,Pajamos Sudėtinės paskyra
DocType: Global Defaults,Hide Currency Symbol,Slėpti valiutos simbolį
apps/erpnext/erpnext/config/non_profit.py +58,Donor information.,Donoro informacija.
apps/erpnext/erpnext/config/accounts.py +330,"e.g. Bank, Cash, Credit Card","pvz bankas, grynieji pinigai, kreditinės kortelės"
DocType: Lead Source,Source Name,šaltinis Vardas
DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Suaugusio kraujo spaudimo normalus palaikymas yra maždaug 120 mmHg sistolinis ir 80 mmHg diastolinis, sutrumpintas &quot;120/80 mmHg&quot;"
DocType: Journal Entry,Credit Note,kredito Pastaba
DocType: Warranty Claim,Service Address,Paslaugų Adresas
DocType: Asset Maintenance Task,Calibration,Kalibravimas
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49,Furnitures and Fixtures,Baldai ir Šviestuvai
DocType: Item,Manufacture,gamyba
apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Company,Sąrankos kompanija
,Lab Test Report,Lab testo ataskaita
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,Pirmasis Prašome Važtaraštis
DocType: Student Applicant,Application Date,paraiškos pateikimo datos
DocType: Salary Detail,Amount based on formula,Suma remiantis formulės
DocType: Purchase Invoice,Currency and Price List,Valiuta ir Kainoraštis
DocType: Opportunity,Customer / Lead Name,Klientas / Švino Vardas
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +99,Clearance Date not mentioned,Sąskaitų data nepaminėta
apps/erpnext/erpnext/config/manufacturing.py +7,Production,Gamyba
DocType: Guardian,Occupation,okupacija
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74,Row {0}:Start Date must be before End Date,Eilutės {0}: pradžios data turi būti prieš End data
DocType: Crop,Planting Area,Apželdinimo zona
apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Iš viso (Kiekis)
DocType: Installation Note Item,Installed Qty,įdiegta Kiekis
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4,This could be because of some invalid Email Addresses in the,Tai gali būti dėl tam tikrų netinkamų el. Pašto adresų
apps/erpnext/erpnext/utilities/user_progress.py +28,You added ,Pridėjote
DocType: Purchase Taxes and Charges,Parenttype,Parenttype
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10,Training Result,Mokymai rezultatas
DocType: Purchase Invoice,Is Paid,yra mokama
DocType: Salary Structure,Total Earning,Iš viso Pelningiausi
DocType: Purchase Receipt,Time at which materials were received,"Laikas, per kurį buvo gauta medžiagos"
DocType: Products Settings,Products per Page,Produktai puslapyje
DocType: Stock Ledger Entry,Outgoing Rate,Siunčiami Balsuok
apps/erpnext/erpnext/config/hr.py +233,Organization branch master.,Organizacija filialas meistras.
apps/erpnext/erpnext/controllers/accounts_controller.py +312, or ,arba
DocType: Sales Order,Billing Status,atsiskaitymo būsena
apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Pranešti apie problemą
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,Utility Expenses,Komunalinė sąnaudos
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,90 Virš
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +241,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Eilutės # {0}: leidinys Įėjimo {1} neturi paskyros {2} arba jau lyginami su kito kuponą
DocType: Supplier Scorecard Criteria,Criteria Weight,Kriterijų svoris
DocType: Buying Settings,Default Buying Price List,Numatytasis Ieško Kainų sąrašas
DocType: Payroll Entry,Salary Slip Based on Timesheet,Pajamos Kuponas Remiantis darbo laiko apskaitos žiniaraštis
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +43,Buying Rate,Pirkimo norma
DocType: Notification Control,Sales Order Message,Pardavimų užsakymų pranešimas
apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Numatytosios reikšmės, kaip kompanija, valiuta, einamuosius fiskalinius metus, ir tt"
DocType: Payment Entry,Payment Type,Mokėjimo tipas
apps/erpnext/erpnext/stock/doctype/batch/batch.py +160,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,"Prašome pasirinkti partiją punktas {0}. Nepavyko rasti vieną partiją, kuri atitinka šį reikalavimą"
apps/erpnext/erpnext/stock/doctype/batch/batch.py +160,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,"Prašome pasirinkti partiją punktas {0}. Nepavyko rasti vieną partiją, kuri atitinka šį reikalavimą"
DocType: Hub Category,Parent Category,Tėvų kategorija
DocType: Payroll Entry,Select Employees,pasirinkite Darbuotojai
DocType: Opportunity,Potential Sales Deal,Galimas Pardavimų Spręsti
DocType: Complaint,Complaints,Skundai
DocType: Payment Entry,Cheque/Reference Date,Čekis / Nuoroda data
DocType: Purchase Invoice,Total Taxes and Charges,Iš viso Mokesčiai ir rinkliavos
DocType: Employee,Emergency Contact,Avarinės pagalbos kontaktinė
DocType: Bank Reconciliation Detail,Payment Entry,Mokėjimo įrašas
DocType: Item,Quality Parameters,kokybės parametrai
,sales-browser,pardavimo-naršyklė
apps/erpnext/erpnext/accounts/doctype/account/account.js +79,Ledger,buhalterijos didžioji knyga
DocType: Patient Medical Record,PMR-,PMR-
DocType: Drug Prescription,Drug Code,Narkotikų kodeksas
DocType: Target Detail,Target  Amount,Tikslinė suma
DocType: POS Profile,Print Format for Online,Spausdinti formatą internete
DocType: Shopping Cart Settings,Shopping Cart Settings,Prekių krepšelis Nustatymai
DocType: Journal Entry,Accounting Entries,apskaitos įrašai
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},Pasikartojantis įrašas. Prašome patikrinti Autorizacija taisyklė {0}
DocType: Journal Entry Account,Reference Due Date,Atskaitos data
DocType: Purchase Order,Ref SQ,teisėjas SQ
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Receipt document must be submitted,Gavimas turi būti pateiktas dokumentas
DocType: Purchase Invoice Item,Received Qty,gavo Kiekis
DocType: Stock Entry Detail,Serial No / Batch,Serijos Nr / Serija
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340,Not Paid and Not Delivered,Nesumokėjo ir nepateikė
DocType: Product Bundle,Parent Item,tėvų punktas
DocType: Account,Account Type,Paskyros tipas
DocType: Delivery Note,DN-RET-,DN-RET-
apps/erpnext/erpnext/templates/pages/projects.html +58,No time sheets,Nėra darbo laiko apskaitos žiniaraščiai
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123,Leave Type {0} cannot be carry-forwarded,"Palikite tipas {0}, negali būti atlikti, perduodami"
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',Priežiūra Tvarkaraštis negeneruojama visų daiktų. Prašome spausti &quot;Generuoti grafiką&quot;
,To Produce,Gaminti
apps/erpnext/erpnext/config/hr.py +93,Payroll,Darbo užmokesčio
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +196,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Dėl eilės {0} iš {1}. Įtraukti {2} prekės norma, eilutės {3} taip pat turi būti įtraukti"
apps/erpnext/erpnext/utilities/activation.py +101,Make User,Padaryti vartotoją
DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikavimas pakuotės už pristatymą (spausdinimui)
DocType: Bin,Reserved Quantity,reserved Kiekis
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,"Prašome įvesti galiojantį elektroninio pašto adresą,"
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,"Prašome įvesti galiojantį elektroninio pašto adresą,"
DocType: Volunteer Skill,Volunteer Skill,Savanorių įgūdis
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +736,Please select an item in the cart,Prašome pasirinkti prekę krepšelyje
DocType: Landed Cost Voucher,Purchase Receipt Items,Pirkimo kvito daiktai
apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,PRITAIKYMAS formos
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74,Arrear,Įsiskolinimas
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158,Depreciation Amount during the period,Turto nusidėvėjimo suma per ataskaitinį laikotarpį
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43,Disabled template must not be default template,Neįgaliųjų šablonas turi būti ne numatytasis šablonas
DocType: Account,Income Account,pajamų sąskaita
DocType: Payment Request,Amount in customer's currency,Suma kliento valiuta
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +823,Delivery,pristatymas
DocType: Volunteer,Weekdays,Darbo dienomis
DocType: Stock Reconciliation Item,Current Qty,Dabartinis Kiekis
DocType: Restaurant Menu,Restaurant Menu,Restorano meniu
apps/erpnext/erpnext/templates/generators/item_group.html +36,Prev,Ankstesnis
DocType: Appraisal Goal,Key Responsibility Area,Pagrindinė atsakomybė Plotas
apps/erpnext/erpnext/utilities/activation.py +127,"Student Batches help you track attendance, assessments and fees for students","Studentų Partijos padėti jums sekti lankomumo, vertinimai ir rinkliavos studentams"
DocType: Payment Entry,Total Allocated Amount,Visos skirtos sumos
apps/erpnext/erpnext/setup/doctype/company/company.py +147,Set default inventory account for perpetual inventory,Nustatykite numatytąjį inventoriaus sąskaitos už amžiną inventoriaus
DocType: Item Reorder,Material Request Type,Medžiaga Prašymas tipas
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252,Accural Journal Entry for salaries from {0} to {1},Accural leidinys Įėjimo atlyginimus iš {0} ir {1}
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17,Send Grant Review Email,Siųsti grantų peržiūrą el. Paštu
apps/erpnext/erpnext/accounts/page/pos/pos.js +840,"LocalStorage is full, did not save","LocalStorage &quot;yra pilna, neišsaugojo"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +95,Row {0}: UOM Conversion Factor is mandatory,Eilutės {0}: UOM konversijos faktorius yra privalomas
apps/erpnext/erpnext/utilities/user_progress.py +232,Room Capacity,Kambarių talpa
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +14,Ref,teisėjas
DocType: Lab Test,LP-,LP-
DocType: Healthcare Settings,Registration Fee,Registracijos mokestis
DocType: Budget,Cost Center,kaina centras
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45,Voucher #,Bon #
DocType: Notification Control,Purchase Order Message,Pirkimui užsakyti pranešimas
DocType: Tax Rule,Shipping Country,Pristatymas Šalis
DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Slėpti Kliento mokesčių ID iš pardavimo sandorių
DocType: Upload Attendance,Upload HTML,Įkelti HTML
DocType: Employee,Relieving Date,malšinančių data
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.","Kainodaros taisyklė yra pagamintas perrašyti Kainoraštis / define diskonto procentas, remiantis kai kuriais kriterijais."
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Sandėlių gali būti pakeista tik per vertybinių popierių Entry / Važtaraštis / Pirkimo gavimas
DocType: Employee Education,Class / Percentage,Klasė / procentas
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134,Head of Marketing and Sales,Vadovas rinkodarai ir pardavimams
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72,Income Tax,Pajamų mokestis
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"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.","Jei pasirinkta kainodaros taisyklė yra numatyta &quot;kaina&quot;, tai bus perrašyti Kainoraštis. Kainodaros taisyklė kaina yra galutinė kaina, todėl turėtų būti taikomas ne toliau nuolaida. Vadinasi, sandorių, pavyzdžiui, pardavimų užsakymų, pirkimo užsakymą ir tt, tai bus pasitinkami ir &quot;norma&quot; srityje, o ne &quot;kainoraštį norma&quot; srityje."
apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,Įrašo Leads pramonės tipo.
apps/erpnext/erpnext/utilities/user_progress.py +98,Go to Letterheads,Eikite į &quot;Letterheads&quot;
DocType: Item Supplier,Item Supplier,Prekė Tiekėjas
apps/erpnext/erpnext/public/js/controllers/transaction.js +1243,Please enter Item Code to get batch no,Prašome įvesti Prekės kodas gauti partiją nėra
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +874,Please select a value for {0} quotation_to {1},Prašome pasirinkti vertę už {0} quotation_to {1}
apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Visi adresai.
DocType: Company,Stock Settings,Akcijų Nustatymai
apps/erpnext/erpnext/accounts/doctype/account/account.py +183,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Sujungimas yra galimas tik tada, jei šie savybės yra tos pačios tiek įrašų. Ar grupė, Šaknų tipas, Įmonės"
DocType: Vehicle,Electric,elektros
DocType: Task,% Progress,% Progresas
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123,Gain/Loss on Asset Disposal,Pelnas / nuostolis turto perdavimo
DocType: Task,Depends on Tasks,Priklauso nuo Užduotys
apps/erpnext/erpnext/config/selling.py +36,Manage Customer Group Tree.,Valdyti klientų grupei medį.
DocType: Shopping Cart Settings,Attachments can be shown without enabling the shopping cart,Priedai gali būti rodomas be leidžianti krepšelis
DocType: Normal Test Items,Result Value,Rezultato vertė
DocType: Supplier Quotation,SQTN-,SQTN-
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22,New Cost Center Name,Nauja kaina centras vardas
DocType: Leave Control Panel,Leave Control Panel,Palikite Valdymo skydas
DocType: Project,Task Completion,užduotis užbaigimas
apps/erpnext/erpnext/templates/includes/product_page.js +21,Not in Stock,Nėra sandėlyje
DocType: Volunteer,Volunteer Skills,Savanorių įgūdžiai
DocType: Appraisal,HR User,HR Vartotojas
DocType: Purchase Invoice,Taxes and Charges Deducted,Mokesčiai ir rinkliavos Išskaityta
apps/erpnext/erpnext/hooks.py +142,Issues,Problemos
apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Statusas turi būti vienas iš {0}
DocType: Sales Invoice,Debit To,debeto
DocType: Restaurant Menu Item,Restaurant Menu Item,Restorano meniu punktas
DocType: Delivery Note,Required only for sample item.,Reikalinga tik imties elemento.
DocType: Stock Ledger Entry,Actual Qty After Transaction,Tikrasis Kiekis Po Sandorio
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +79,No salary slip found between {0} and {1},Ne darbo užmokestį rasti tarp {0} ir {1}
,Pending SO Items For Purchase Request,Kol SO daiktai įsigyti Užsisakyti
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35,Student Admissions,studentų Priėmimo
apps/erpnext/erpnext/accounts/party.py +376,{0} {1} is disabled,{0} {1} yra išjungtas
DocType: Supplier,Billing Currency,atsiskaitymo Valiuta
DocType: Sales Invoice,SINV-RET-,SINV-RET-
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200,Extra Large,Labai didelis
DocType: Crop,Scientific Name,Mokslinis vardas
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Leaves,Iš viso lapai
DocType: Consultation,In print,Spausdinti
,Profit and Loss Statement,Pelno ir nuostolio ataskaita
DocType: Bank Reconciliation Detail,Cheque Number,Komunalinės Taškų
,Sales Browser,pardavimų naršyklė
DocType: Journal Entry,Total Credit,Kreditai
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +540,Warning: Another {0} # {1} exists against stock entry {2},Įspėjimas: Kitas {0} # {1} egzistuoja nuo akcijų įrašą {2}
apps/erpnext/erpnext/utilities/user_progress_utils.py +66,Local,vietinis
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Paskolos ir avansai (turtas)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,skolininkai
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199,Large,Didelis
DocType: Homepage Featured Product,Homepage Featured Product,Pagrindinis puslapis Teminiai Prekės
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +246,All Assessment Groups,Visi Vertinimo Grupės
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Naujas sandėlys Vardas
apps/erpnext/erpnext/accounts/report/financial_statements.py +233,Total {0} ({1}),Viso {0} ({1})
DocType: C-Form Invoice Detail,Territory,teritorija
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,Please mention no of visits required,Paminėkite nėra apsilankymų reikalingų
DocType: Stock Settings,Default Valuation Method,Numatytasis vertinimo metodas
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26,Fee,Rinkliava
apps/erpnext/erpnext/setup/doctype/company/company.js +154,Update in progress. It might take a while.,Atnaujinimas vyksta. Tai gali užtrukti.
DocType: Vehicle Log,Fuel Qty,kuro Kiekis
DocType: Production Order Operation,Planned Start Time,Planuojamas Pradžios laikas
DocType: Course,Assessment,įvertinimas
DocType: Payment Entry Reference,Allocated,Paskirti
apps/erpnext/erpnext/config/accounts.py +267,Close Balance Sheet and book Profit or Loss.,Uždaryti Balansas ir knyga pelnas arba nuostolis.
DocType: Student Applicant,Application Status,paraiškos būseną
DocType: Sensitivity Test Items,Sensitivity Test Items,Jautrumo testo elementai
DocType: Fees,Fees,Mokesčiai
DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Nurodykite Valiutų kursai konvertuoti vieną valiutą į kitą
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159,Quotation {0} is cancelled,Citata {0} atšaukiamas
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Outstanding Amount,Iš viso neapmokėta suma
DocType: Sales Partner,Targets,tikslai
DocType: Price List,Price List Master,Kainų sąrašas magistras
DocType: GST Account,CESS Account,CESS sąskaita
DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Visi pardavimo sandoriai gali būti pažymėti prieš kelis ** pardavėjai **, kad būtų galima nustatyti ir stebėti tikslus."
,S.O. No.,SO Nr
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241,Please create Customer from Lead {0},Prašome sukurti klientui Švinas {0}
apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,Select Patient,Pasirinkite pacientą
DocType: Price List,Applicable for Countries,Taikoma šalių
DocType: Supplier Scorecard Scoring Variable,Parameter Name,Parametro pavadinimas
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,gali būti pateiktas palikti tik programas su statusu &quot;Patvirtinta&quot; ir &quot;Atmesta&quot;
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52,Student Group Name is mandatory in row {0},Studentų grupės pavadinimas yra privalomas eilės {0}
DocType: Homepage,Products to be shown on website homepage,Produktai turi būti rodomas svetainės puslapyje
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,Tai yra šaknis klientas grupė ir negali būti pakeisti.
DocType: Student,AB-,AB-
DocType: POS Profile,Ignore Pricing Rule,Ignoruoti kainodaros taisyklė
DocType: Employee Education,Graduate,absolventas
DocType: Leave Block List,Block Days,Blokuoti dienų
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83,"Shipping Address does not have country, which is required for this Shipping Rule","Laivybos adresas neturi šalies, kuri reikalinga šiam siuntimo taisyklėm"
DocType: Journal Entry,Excise Entry,akcizo įrašas
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Įspėjimas: pardavimų užsakymų {0} jau egzistuoja nuo Kliento Užsakymo {1}
DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.

Examples:

1. Validity of the offer.
1. Payment Terms (In Advance, On Credit, part advance etc).
1. What is extra (or payable by the Customer).
1. Safety / usage warning.
1. Warranty if any.
1. Returns Policy.
1. Terms of shipping, if applicable.
1. Ways of addressing disputes, indemnity, liability, etc.
1. Address and Contact of your Company.","Standartinės sąlygos, kurios gali būti įtrauktos į pardavimo ir pirkimo. Pavyzdžiai: 1. galiojimas pasiūlymą. 1. Mokėjimo sąlygos (iš anksto, kredito, dalis avanso ir tt). 1. Kas yra papildomų (arba turėtų sumokėti Užsakovui). 1. Saugumas / naudojimas įspėjimo. 1. Garantija, jei tokių yra. 1. grąžinimo politiką. 1. Terminai laivybos, jei taikoma. 1. būdus, kaip spręsti ginčus, civilinės atsakomybės, atsakomybės ir tt 1. Adresas ir kontaktai Jūsų įmonėje."
DocType: Issue,Issue Type,Problemos tipas
DocType: Attendance,Leave Type,atostogos tipas
DocType: Purchase Invoice,Supplier Invoice Details,Tiekėjas Sąskaitos informacija
DocType: Agriculture Task,Ignore holidays,Ignoruoti atostogas
apps/erpnext/erpnext/controllers/stock_controller.py +233,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Kompensuojamos / Skirtumas sąskaita ({0}) turi būti &quot;pelnas arba nuostolis&quot; sąskaita
DocType: Project,Copied From,Nukopijuota iš
DocType: Project,Copied From,Nukopijuota iš
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96,Name error: {0},Vardas klaida: {0}
apps/erpnext/erpnext/stock/doctype/item/item_list.js +12,Shortage,Trūkumas
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,Attendance for employee {0} is already marked,Lankomumas darbuotojo {0} jau yra pažymėtas
DocType: Packing Slip,If more than one package of the same type (for print),Jeigu yra daugiau nei vienas paketas tos pačios rūšies (spausdinimui)
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27,Please set default customer in Restaurant Settings,Nustatykite numatytąjį klientą Restoranų nustatymuose
,Salary Register,Pajamos Registruotis
DocType: Warehouse,Parent Warehouse,tėvų sandėlis
DocType: C-Form Invoice Detail,Net Total,grynasis Iš viso
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +527,Default BOM not found for Item {0} and Project {1},Numatytąją BOM ne punktą rasti {0} ir projekto {1}
apps/erpnext/erpnext/config/hr.py +168,Define various loan types,Apibrėžti įvairių paskolų tipų
DocType: Bin,FCFS Rate,FCFS Balsuok
DocType: Opening Invoice Creation Tool Item,Outstanding Amount,nesumokėtos sumos
apps/erpnext/erpnext/templates/generators/bom.html +71,Time(in mins),Laikas (min)
DocType: Project Task,Working,darbo
DocType: Stock Ledger Entry,Stock Queue (FIFO),Akcijų eilę (FIFO)
apps/erpnext/erpnext/public/js/setup_wizard.js +127,Financial Year,Finansiniai metai
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46,{0} does not belong to Company {1},{0} nepriklauso Company {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.,"Nepavyko spręsti {0} kriterijų rezultatų funkcijos. Įsitikinkite, kad formulė galioja."
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122,Cost as on,Kainuoti apie
DocType: Healthcare Settings,Out Patient Settings,Išeikite paciento nustatymus
DocType: Account,Round Off,suapvalinti
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +252,Quantity must be positive,Kiekis turi būti teigiamas
,Requested Qty,prašoma Kiekis
DocType: Tax Rule,Use for Shopping Cart,Naudokite krepšelį
apps/erpnext/erpnext/controllers/item_variant.py +96,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},Vertė {0} atributas {1} neegzistuoja taikomi tinkamos prekių ar paslaugų sąrašą Įgūdis vertes punkte {2}
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79,Select Serial Numbers,Pasirinkite serijos numeriu
DocType: BOM Item,Scrap %,laužas%
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","Mokesčiai bus platinamas proporcingai remiantis punktas Kiekis arba sumos, kaip už savo pasirinkimą"
DocType: Maintenance Visit,Purposes,Tikslai
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +111,Atleast one item should be entered with negative quantity in return document,Atleast vienas punktas turi būti įrašomas neigiamas kiekio grąžinimo dokumentą
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","Operacija {0} ilgiau nei bet kokiomis darbo valandų darbo vietos {1}, suskaidyti operaciją į kelių operacijų"
DocType: Membership,Membership Status,Narystės statusas
,Requested,prašoma
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93,No Remarks,nėra Pastabos
DocType: Asset,In Maintenance,Priežiūra
DocType: Purchase Invoice,Overdue,pavėluotas
DocType: Account,Stock Received But Not Billed,"Vertybinių popierių gaunamas, bet nereikia mokėti"
apps/erpnext/erpnext/accounts/doctype/account/account.py +84,Root Account must be a group,Šaknų sąskaita turi būti grupė
DocType: Consultation,Drug Prescription,Narkotikų recepcija
DocType: Fees,FEE.,RINKLIAVA.
DocType: Employee Loan,Repaid/Closed,Grąžinama / Uždarymo
DocType: Item,Total Projected Qty,Iš viso prognozuojama Kiekis
DocType: Monthly Distribution,Distribution Name,platinimo Vardas
apps/erpnext/erpnext/stock/stock_ledger.py +471,"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","Prekės {0} neįvertinta, kuri reikalinga apskaitos įrašams atlikti {1} {2}. Jei objektas sandoriuos kaip nulinis vertinimo koeficiento elementas {1}, prašome paminėti tai {1} elemento lentelėje. Priešingu atveju, sukurkite gautą atsarginį sandorį elementui arba paminėkite vertinimo rodiklį elemento įraše, tada pabandykite pateikti / atšaukti šį įrašą"
DocType: Course,Course Code,Dalyko kodas
apps/erpnext/erpnext/controllers/stock_controller.py +331,Quality Inspection required for Item {0},Kokybės inspekcija privalo už prekę {0}
DocType: POS Settings,Use POS in Offline Mode,Naudokite POS neprisijungus
DocType: Supplier Scorecard,Supplier Variables,Tiekėjo kintamieji
DocType: Quotation,Rate at which customer's currency is converted to company's base currency,"Norma, pagal kurią klientas valiuta yra konvertuojamos į įmonės bazine valiuta"
DocType: Purchase Invoice Item,Net Rate (Company Currency),Grynoji palūkanų normos (Įmonės valiuta)
DocType: Salary Detail,Condition and Formula Help,Būklė ir &quot;Formula Pagalba
apps/erpnext/erpnext/config/selling.py +105,Manage Territory Tree.,Tvarkyti Teritorija medį.
DocType: Journal Entry Account,Sales Invoice,pardavimų sąskaita faktūra
DocType: Journal Entry Account,Party Balance,šalis balansas
apps/erpnext/erpnext/accounts/page/pos/pos.js +498,Please select Apply Discount On,Prašome pasirinkti Taikyti nuolaidą
DocType: Stock Settings,Sample Retention Warehouse,Mėginio saugojimo sandėlis
DocType: Company,Default Receivable Account,Numatytasis Gautinos sąskaitos
DocType: Physician,Physician Schedule,Gydytojo tvarkaraštis
DocType: Purchase Invoice,Deemed Export,Laikomas eksportas
DocType: Stock Entry,Material Transfer for Manufacture,Medžiagos pernešimas gamybai
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.,Nuolaida procentas gali būti taikomas bet prieš kainoraštis arba visų kainų sąrašas.
DocType: Subscription,Half-yearly,Kartą per pusmetį
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +407,Accounting Entry for Stock,Apskaitos įrašas už Sandėlyje
DocType: Lab Test,LabTest Approver,&quot;LabTest&quot; patvirtintojai
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +61,You have already assessed for the assessment criteria {}.,Jūs jau įvertintas vertinimo kriterijus {}.
DocType: Vehicle Service,Engine Oil,Variklio alyva
DocType: Sales Invoice,Sales Team1,pardavimų team1
apps/erpnext/erpnext/stock/doctype/item/item.py +521,Item {0} does not exist,Prekė {0} neegzistuoja
DocType: Sales Invoice,Customer Address,Klientų Adresas
DocType: Employee Loan,Loan Details,paskolos detalės
DocType: Company,Default Inventory Account,Numatytasis Inventorius paskyra
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124,Row {0}: Completed Qty must be greater than zero.,Eilutės {0}: baigė Kiekis turi būti didesnė už nulį.
DocType: Antibiotic,Antibiotic Name,Antibiotiko pavadinimas
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Prekės kodas&gt; Prekės grupė&gt; Gamintojas
DocType: Purchase Invoice,Apply Additional Discount On,Būti taikomos papildomos nuolaida
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +69,Select Type...,Pasirinkite tipą ...
DocType: Crop Cycle,A link to all the Land Units in which the Crop is growing,"Nuoroda į visus Žemės vienetus, kuriuose auga augalas"
DocType: Account,Root Type,Šaknų tipas
DocType: Item,FIFO,FIFO
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +132,Row # {0}: Cannot return more than {1} for Item {2},Eilutės # {0}: negali grįžti daugiau nei {1} už prekę {2}
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +45,Plot,sklypas
DocType: Item Group,Show this slideshow at the top of the page,Parodyti šią demonstraciją prie puslapio viršuje
DocType: BOM,Item UOM,Prekė UOM
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),"Mokesčių suma, nuolaidos suma (Įmonės valiuta)"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +160,Target warehouse is mandatory for row {0},Tikslinė sandėlis yra privalomas eilės {0}
DocType: Cheque Print Template,Primary Settings,pirminiai nustatymai
DocType: Purchase Invoice,Select Supplier Address,Pasirinkite Tiekėjas Adresas
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Add Employees,Pridėti Darbuotojai
DocType: Purchase Invoice Item,Quality Inspection,kokybės inspekcija
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196,Extra Small,Papildomas Mažas
DocType: Company,Standard Template,standartinį šabloną
DocType: Training Event,Theory,teorija
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +805,Warning: Material Requested Qty is less than Minimum Order Qty,Įspėjimas: Medžiaga Prašoma Kiekis yra mažesnis nei minimalus užsakymas Kiekis
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211,Account {0} is frozen,Sąskaita {0} yra sušaldyti
DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,"Juridinio asmens / Dukterinė įmonė su atskiru Chart sąskaitų, priklausančių organizacijos."
DocType: Payment Request,Mute Email,Nutildyti paštas
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29,"Food, Beverage & Tobacco","Maistas, gėrimai ir tabako"
DocType: Account,Account Number,Paskyros numeris
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +714,Can only make payment against unbilled {0},Gali tik sumokėti prieš Neapmokestinama {0}
apps/erpnext/erpnext/controllers/selling_controller.py +101,Commission rate cannot be greater than 100,Komisinis mokestis gali būti ne didesnė kaip 100
DocType: Volunteer,Volunteer,Savanoris
DocType: Stock Entry,Subcontract,subrangos sutartys
apps/erpnext/erpnext/public/js/utils/party.js +165,Please enter {0} first,Prašome įvesti {0} pirmas
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +87,No replies from,Nėra atsakymų
DocType: Production Order Operation,Actual End Time,Tikrasis Pabaigos laikas
DocType: Production Planning Tool,Download Materials Required,Parsisiųsti Reikalingos medžiagos
DocType: Item,Manufacturer Part Number,Gamintojo kodas
DocType: Production Order Operation,Estimated Time and Cost,Numatoma trukmė ir kaina
DocType: Bin,Bin,dėžė
DocType: Crop,Crop Name,Paskirstymo pavadinimas
DocType: SMS Log,No of Sent SMS,Nėra išsiųstų SMS
DocType: Antibiotic,Healthcare Administrator,Sveikatos priežiūros administratorius
apps/erpnext/erpnext/utilities/user_progress.py +44,Set a Target,Nustatykite tikslą
DocType: Dosage Strength,Dosage Strength,Dozės stiprumas
DocType: Account,Expense Account,Kompensuojamos paskyra
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,programinė įranga
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203,Colour,Spalva
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Vertinimo planas kriterijai
DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Užkirsti kelią pirkimo užsakymams
apps/erpnext/erpnext/healthcare/setup.py +258,Susceptible,Jautrus
DocType: Patient Appointment,Scheduled,planuojama
apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Užklausimas.
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",Prašome pasirinkti Elementą kur &quot;Ar riedmenys&quot; yra &quot;Ne&quot; ir &quot;Ar Pardavimų punktas&quot; yra &quot;Taip&quot; ir nėra jokio kito Prekės Rinkinys
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148,Select Customer,Pasirinkite klientą
DocType: Student Log,Academic,akademinis
DocType: Patient,Personal and Social History,Asmeninė ir socialinė istorija
apps/erpnext/erpnext/education/doctype/guardian/guardian.py +52,User {0} created,Naudotojas {0} sukūrė
DocType: Fee Schedule,Fee Breakup for each student,Mokesčio perviršis kiekvienam studentui
apps/erpnext/erpnext/controllers/accounts_controller.py +540,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Iš viso avansas ({0}) prieš ordino {1} negali būti didesnis nei IŠ VISO ({2})
DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Pasirinkite Mėnesio pasiskirstymas į netolygiai paskirstyti tikslus visoje mėnesius.
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78,Change Code,Keisti kodą
DocType: Purchase Invoice Item,Valuation Rate,Vertinimo Balsuok
DocType: Stock Reconciliation,SR/,SR /
DocType: Vehicle,Diesel,dyzelinis
apps/erpnext/erpnext/stock/get_item_details.py +386,Price List Currency not selected,Kainų sąrašas Valiuta nepasirinkote
,Student Monthly Attendance Sheet,Studentų Mėnesio Lankomumas lapas
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96,Shipping rule only applicable for Selling,Pristatymo taisyklė taikoma tik Pardavimui
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +185,Employee {0} has already applied for {1} between {2} and {3},Darbuotojų {0} jau yra kreipęsis dėl {1} tarp {2} ir {3}
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Projekto pradžia
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +5,Until,iki
DocType: Rename Tool,Rename Log,pervadinti Prisijungti
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Studentų grupė ar užsiėmimų tvarkaraštis yra privalomi
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Studentų grupė ar užsiėmimų tvarkaraštis yra privalomi
DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,Išlaikyti Atsiskaitymo valandas ir darbo valandų patį laiko apskaitos žiniaraštis
DocType: Maintenance Visit Purpose,Against Document No,Su dokumentų Nr
DocType: BOM,Scrap,metalo laužas
apps/erpnext/erpnext/utilities/user_progress.py +214,Go to Instructors,Eiti instruktoriams
apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Tvarkyti Pardavimų Partneriai.
DocType: Quality Inspection,Inspection Type,Patikrinimo tipas
DocType: Fee Validity,Visited yet,Aplankė dar
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +135,Warehouses with existing transaction can not be converted to group.,Sandėliai su esamais sandoris negali būti konvertuojamos į grupę.
DocType: Assessment Result Tool,Result HTML,rezultatas HTML
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6,Memeber Activity,Bembero veikla
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35,Expires On,Baigia galioti
apps/erpnext/erpnext/utilities/activation.py +117,Add Students,Pridėti Studentai
apps/erpnext/erpnext/public/js/utils.js +264,Please select {0},Prašome pasirinkti {0}
DocType: C-Form,C-Form No,C-formos Nėra
DocType: BOM,Exploded_items,Exploded_items
apps/erpnext/erpnext/utilities/user_progress.py +136,List your products or services that you buy or sell.,"Nurodykite savo produktus ar paslaugas, kurias perkate ar parduodate."
DocType: Water Analysis,Storage Temperature,Laikymo temperatūra
DocType: Employee Attendance Tool,Unmarked Attendance,priežiūros Lankomumas
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137,Researcher,tyrėjas
DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Programos Įrašas įrankis Studentų
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16,Start date should be less than end date for task {0},Pradžios data turi būti mažesnė už užduoties pabaigos datą {0}
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Vardas arba el privaloma
DocType: Instructor,Instructor Log,Instruktorių žurnalas
DocType: Purchase Order Item,Returned Qty,grįžo Kiekis
DocType: Student,Exit,išeiti
apps/erpnext/erpnext/accounts/doctype/account/account.py +156,Root Type is mandatory,Šaknų tipas yra privalomi
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29,Failed to install presets,Nepavyko įdiegti iš anksto nustatytų nustatymų
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +42,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.","{0} šiuo metu turi {1} tiekėjų rezultatų kortelę, o šio tiekėjo RFQ turėtų būti pateikiama atsargiai."
DocType: Chapter,Non Profit Manager,Ne pelno administratorius
DocType: BOM,Total Cost(Company Currency),Iš viso išlaidų (Įmonės valiuta)
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315,Serial No {0} created,Serijos Nr {0} sukūrė
DocType: Homepage,Company Description for website homepage,Įmonės aprašymas interneto svetainės pagrindiniame puslapyje
DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Dėl klientų patogumui, šie kodai gali būti naudojami spausdinimo formatus, pavyzdžiui, sąskaitose ir važtaraščiuose"
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18,Suplier Name,suplier Vardas
apps/erpnext/erpnext/accounts/report/financial_statements.py +152,Could not retrieve information for {0}.,Nepavyko gauti informacijos apie {0}.
DocType: Sales Invoice,Time Sheet List,Laikas lapas sąrašas
DocType: Employee,You can enter any date manually,Galite įvesti bet kokį datą rankiniu būdu
DocType: Healthcare Settings,Result Printed,Rezultatas spausdintas
DocType: Asset Category Account,Depreciation Expense Account,Nusidėvėjimo sąnaudos paskyra
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +231,Probationary Period,Bandomasis laikotarpis
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32,View {0},Peržiūrėti {0}
DocType: Customer Group,Only leaf nodes are allowed in transaction,Tik lapų mazgai leidžiama sandorio
DocType: Project,Total Costing Amount (via Timesheets),Bendra sąnaudų suma (per laiko lapus)
DocType: Employee Advance,Expense Approver,Kompensuojamos Tvirtintojas
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +134,Row {0}: Advance against Customer must be credit,Eilutės {0}: Išankstinis prieš užsakovui turi būti kredito
apps/erpnext/erpnext/accounts/doctype/account/account.js +89,Non-Group to Group,Ne grupė į grupę
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Partijos yra imperatyvaus eilės {0}
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Partijos yra imperatyvaus eilės {0}
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Pirkimo kvito punktas Pateikiamas
DocType: Payment Entry,Pay,mokėti
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,Norėdami datetime
apps/erpnext/erpnext/config/selling.py +297,Logs for maintaining sms delivery status,Rąstai išlaikyti sms būsenos
DocType: Accounts Settings,Make Payment via Journal Entry,Atlikti mokėjimą per žurnalo įrašą
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +97,Printed On,Atspausdinta ant
DocType: Item,Inspection Required before Delivery,Patikrinimo Reikalinga prieš Pristatymas
DocType: Item,Inspection Required before Purchase,Patikrinimo Reikalinga prieš perkant
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,Kol veiklos
DocType: Patient Appointment,Reminded,Primena
DocType: Patient,PID-,PID-
DocType: Chapter Member,Chapter Member,Skyrius narys
apps/erpnext/erpnext/public/js/setup_wizard.js +106,Your Organization,Jūsų organizacija
DocType: Fee Component,Fees Category,Mokesčiai Kategorija
apps/erpnext/erpnext/hr/doctype/employee/employee.py +134,Please enter relieving date.,Prašome įvesti malšinančių datą.
apps/erpnext/erpnext/controllers/trends.py +149,Amt,amt
DocType: Supplier Scorecard,Notify Employee,Pranešti darbuotojui
DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,Įveskite vardą kampanijos jei šaltinis tyrimo yra akcija
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38,Newspaper Publishers,laikraščių leidėjai
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30,Select Fiscal Year,Pasirinkite finansiniai metai
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115,Expected Delivery Date should be after Sales Order Date,Laukiama pristatymo data turėtų būti pateikta po Pardavimų užsakymo data
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Pertvarkyti lygis
DocType: Company,Chart Of Accounts Template,Sąskaitų planas Šablonas
DocType: Attendance,Attendance Date,lankomumas data
apps/erpnext/erpnext/stock/get_item_details.py +350,Item Price updated for {0} in Price List {1},Prekė Kaina atnaujintas {0} kainoraštis {1}
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Pajamos Griauti remiantis uždirbti ir atskaitą.
apps/erpnext/erpnext/accounts/doctype/account/account.py +128,Account with child nodes cannot be converted to ledger,Sąskaita su vaikų mazgų negali būti konvertuojamos į sąskaitų knygos
DocType: Purchase Invoice Item,Accepted Warehouse,Priimamos sandėlis
DocType: Bank Reconciliation Detail,Posting Date,Išsiuntimo data
DocType: Item,Valuation Method,vertinimo metodas
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203,Mark Half Day,Pažymėti Pusė dienos
DocType: Sales Invoice,Sales Team,Sales Team
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +87,Duplicate entry,pasikartojantis įrašas
DocType: Program Enrollment Tool,Get Students,Gauk Studentai
DocType: Serial No,Under Warranty,pagal Garantija
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +515,[Error],[ERROR]
DocType: Sales Order,In Words will be visible once you save the Sales Order.,"Žodžiais bus matomas, kai jūs išgelbėti pardavimų užsakymų."
,Employee Birthday,Darbuotojų Gimimo diena
apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14,Please select Completion Date for Completed Repair,Prašome pasirinkti užbaigto remonto užbaigimo datą
DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Studentų Serija Lankomumas įrankis
apps/erpnext/erpnext/controllers/status_updater.py +210,Limit Crossed,riba Crossed
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Suplanuotas iki
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55,Venture Capital,Venture Capital &quot;
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.,Akademinis terminas su šia &quot;Akademinio metų&quot; {0} ir &quot;Terminas Vardas&quot; {1} jau egzistuoja. Prašome pakeisti šiuos įrašus ir pabandykite dar kartą.
DocType: UOM,Must be Whole Number,Turi būti sveikasis skaičius
DocType: Leave Control Panel,New Leaves Allocated (In Days),Naujų lapų Pervedimaiį (dienomis)
DocType: Purchase Invoice,Invoice Copy,sąskaitos kopiją
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,Serijos Nr {0} neegzistuoja
DocType: Sales Invoice Item,Customer Warehouse (Optional),Klientų Sandėlis (neprivalomas)
DocType: Pricing Rule,Discount Percentage,Nuolaida procentas
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Reserved for sub contracting,Rezervuota subrangovams
DocType: Payment Reconciliation Invoice,Invoice Number,Sąskaitos numeris
DocType: Shopping Cart Settings,Orders,Užsakymai
DocType: Employee Leave Approver,Leave Approver,Palikite jį patvirtinusio
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285,Please select a batch,Prašome pasirinkti partiją
DocType: Assessment Group,Assessment Group Name,Vertinimas Grupės pavadinimas
DocType: Manufacturing Settings,Material Transferred for Manufacture,"Medžiagos, perduotos gamybai"
DocType: Expense Claim,"A user with ""Expense Approver"" role",Vartotojas su &quot;išlaidų Tvirtintojas&quot; vaidmenį
DocType: Landed Cost Item,Receipt Document Type,Gavimas Dokumento tipas
DocType: Daily Work Summary Settings,Select Companies,Atrenkame įmones
,Issued Items Against Production Order,Išleisti Daiktai juos nuo gamybos ordino
DocType: Antibiotic,Healthcare,Sveikatos apsauga
DocType: Target Detail,Target Detail,Tikslinė detalės
apps/erpnext/erpnext/stock/doctype/item/item.js +65,Single Variant,Vienas variantas
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24,All Jobs,Visi Darbai
DocType: Sales Order,% of materials billed against this Sales Order,% Medžiagų yra mokami nuo šio pardavimo užsakymų
DocType: Program Enrollment,Mode of Transportation,Transporto režimas
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49,Period Closing Entry,Laikotarpis uždarymas Įėjimas
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +75,Select Department...,Pasirinkite skyrių ...
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38,Cost Center with existing transactions can not be converted to group,Kaina centras su esamais sandoriai negali būti konvertuojamos į grupės
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +361,Amount {0} {1} {2} {3},Suma {0} {1} {2} {3}
DocType: Account,Depreciation,amortizacija
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),Tiekėjas (-ai)
DocType: Employee Attendance Tool,Employee Attendance Tool,Darbuotojų dalyvavimas įrankis
DocType: Guardian Student,Guardian Student,&quot;guardian&quot; Studentų
DocType: Supplier,Credit Limit,Kredito limitas
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Selling Price List Rate,Vidur. Pardavimo kainų sąrašo norma
DocType: Production Plan Sales Order,Salse Order Date,Purvo vulkanas Užsakyti data
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Tiekėjas&gt; Tiekėjo tipas
DocType: Salary Component,Salary Component,Pajamos komponentas
apps/erpnext/erpnext/accounts/utils.py +495,Payment Entries {0} are un-linked,Apmokėjimo Įrašai {0} yra JT susietų
DocType: GL Entry,Voucher No,Bon Nėra
,Lead Owner Efficiency,Švinas Savininko efektyvumas
,Lead Owner Efficiency,Švinas Savininko efektyvumas
apps/erpnext/erpnext/hub_node/page/hub/hub.js +195,Most Popular,Populiariausias
DocType: Leave Allocation,Leave Allocation,Palikite paskirstymas
DocType: Payment Request,Recipient Message And Payment Details,Gavėjas pranešimą ir Mokėjimo informacija
DocType: Training Event,Trainer Email,treneris paštas
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550,Material Requests {0} created,Medžiaga Prašymai {0} sukūrė
DocType: Restaurant Reservation,No of People,Žmonių skaičius
DocType: Production Planning Tool,Include sub-contracted raw materials,Įtraukti SUBRANGOVAMS žaliavas
apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Šablonas terminų ar sutarties.
DocType: Purchase Invoice,Address and Contact,Adresas ir kontaktai
DocType: Cheque Print Template,Is Account Payable,Ar sąskaita Mokėtinos sumos
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276,Stock cannot be updated against Purchase Receipt {0},"Akcijų, negali būti atnaujintas prieš pirkimo kvito {0}"
DocType: Company,Last Day of the Next Month,Paskutinė diena iki kito mėnesio
DocType: Support Settings,Auto close Issue after 7 days,Auto arti išdavimas po 7 dienų
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +71,"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Palikite negali būti skiriama iki {0}, kaip atostogos balansas jau perkėlimo persiunčiami būsimos atostogos paskirstymo įrašo {1}"
apps/erpnext/erpnext/accounts/party.py +320,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Pastaba: Dėl / Nuoroda data viršija leidžiama klientų kredito dienas iki {0} dieną (-ai)
apps/erpnext/erpnext/education/doctype/program/program.js +8,Student Applicant,Studentų Pareiškėjas
DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,Originalus GAVĖJAS
DocType: Asset Category Account,Accumulated Depreciation Account,Sukauptas nusidėvėjimas paskyra
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11,This email is autogenerated,Šis el. Laiškas yra automatiškai sukurtas
DocType: Stock Settings,Freeze Stock Entries,Freeze Akcijų įrašai
DocType: Program Enrollment,Boarding Student,internatinė Studentų
DocType: Asset,Expected Value After Useful Life,Tikimasi Vertė Po naudingo tarnavimo
DocType: Item,Reorder level based on Warehouse,Pertvarkyti lygį remiantis Warehouse
DocType: Activity Cost,Billing Rate,atsiskaitymo Balsuok
,Qty to Deliver,Kiekis pristatyti
,Stock Analytics,Akcijų Analytics &quot;
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +508,Operations cannot be left blank,Operacijos negali būti paliktas tuščias
DocType: Maintenance Visit Purpose,Against Document Detail No,Su dokumentų Išsamiau Nėra
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +99,Party Type is mandatory,Šalis tipas yra privalomi
DocType: Quality Inspection,Outgoing,išeinantis
DocType: Material Request,Requested For,prašoma Dėl
DocType: Quotation Item,Against Doctype,prieš DOCTYPE
apps/erpnext/erpnext/controllers/buying_controller.py +414,{0} {1} is cancelled or closed,{0} {1} yra atšaukiamas arba uždarė
DocType: Asset,Calculate Depreciation,Apskaičiuokite nusidėvėjimą
DocType: Delivery Note,Track this Delivery Note against any Project,Sekti šią važtaraštyje prieš bet kokį projektą
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +30,Net Cash from Investing,Grynieji pinigų srautai iš investicinės
DocType: Production Order,Work-in-Progress Warehouse,Darbas-in-progress Warehouse
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Turto {0} turi būti pateiktas
DocType: Fee Schedule Program,Total Students,Iš viso studentų
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56,Attendance Record {0} exists against Student {1},Lankomumas Įrašų {0} egzistuoja nuo Studentų {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +352,Reference #{0} dated {1},Nuoroda # {0} data {1}
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164,Depreciation Eliminated due to disposal of assets,Nusidėvėjimas Pašalintas dėl turto perleidimo
DocType: Member,Member,Narys
apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,tvarkyti adresai
DocType: Pricing Rule,Item Code,Prekės kodas
DocType: Production Planning Tool,Create Production Orders,Sukurti gamybos užsakymus
DocType: Serial No,Warranty / AMC Details,Garantija / AMC detalės
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Pasirinkite studentai rankiniu veikla grindžiamo grupės
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Pasirinkite studentai rankiniu veikla grindžiamo grupės
DocType: Journal Entry,User Remark,vartotojas Pastaba
DocType: Lead,Market Segment,Rinkos segmentas
DocType: Agriculture Analysis Criteria,Agriculture Manager,Žemės ūkio vadybininkas
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +950,Paid Amount cannot be greater than total negative outstanding amount {0},Sumokėta suma negali būti didesnė nei visos neigiamos nesumokėtos sumos {0}
DocType: Supplier Scorecard Period,Variables,Kintamieji
DocType: Employee Internal Work History,Employee Internal Work History,Darbuotojų vidaus darbo Istorija
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +246,Closing (Dr),Uždarymo (dr)
DocType: Cheque Print Template,Cheque Size,Komunalinės dydis
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232,Serial No {0} not in stock,Serijos Nr {0} nėra sandėlyje
apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,Mokesčių šablonas pardavimo sandorius.
DocType: Sales Invoice,Write Off Outstanding Amount,Nurašyti likutinę sumą
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27,Account {0} does not match with Company {1},Sąskaita {0} nesutampa su kompanija {1}
DocType: Education Settings,Current Academic Year,Dabartinis akademiniai metai
DocType: Education Settings,Current Academic Year,Dabartinis akademiniai metai
DocType: Stock Settings,Default Stock UOM,Numatytasis sandėlyje UOM
DocType: Asset,Number of Depreciations Booked,Užsakytas skaičius nuvertinimai
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32,Against Employee Loan: {0},Prieš darbuotojo Loan: {0}
DocType: Landed Cost Item,Receipt Document,gavimas Dokumentų
DocType: Production Planning Tool,Create Material Requests,Sukurti Materialieji Prašymai
DocType: Employee Education,School/University,Mokykla / Universitetas
DocType: Payment Request,Reference Details,nuoroda detalės
apps/erpnext/erpnext/assets/doctype/asset/asset.py +56,Expected Value After Useful Life must be less than Gross Purchase Amount,Tikimasi Vertė Po naudingo tarnavimo laiką turi būti mažesnis nei bendrojo pirkinio sumos
DocType: Sales Invoice Item,Available Qty at Warehouse,Turimas Kiekis į sandėlį
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,įvardintas suma
DocType: Asset,Double Declining Balance,Dvivietis mažėjančio balanso
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180,Closed order cannot be cancelled. Unclose to cancel.,Uždaras nurodymas negali būti atšauktas. Atskleisti atšaukti.
DocType: Student Guardian,Father,tėvas
apps/erpnext/erpnext/controllers/accounts_controller.py +626,'Update Stock' cannot be checked for fixed asset sale,&quot;Atnaujinti sandėlyje&quot; negali būti patikrinta dėl ilgalaikio turto pardavimo
DocType: Bank Reconciliation,Bank Reconciliation,bankas suderinimas
DocType: Attendance,On Leave,atostogose
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,Gaukite atnaujinimus
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Sąskaitos {2} nepriklauso Company {3}
apps/erpnext/erpnext/stock/doctype/item/item.js +366,Select at least one value from each of the attributes.,Pasirinkite bent vieną vertę iš kiekvieno atributo.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +162,Material Request {0} is cancelled or stopped,Medžiaga Prašymas {0} atšauktas ar sustabdytas
apps/erpnext/erpnext/config/hr.py +310,Leave Management,Palikite valdymas
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +106,Group by Account,Grupė sąskaitų
DocType: Sales Order,Fully Delivered,pilnai Paskelbta
DocType: Lead,Lower Income,mažesnes pajamas
DocType: Restaurant Order Entry,Current Order,Dabartinis užsakymas
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +179,Source and target warehouse cannot be same for row {0},Originalo ir vertimo sandėlis negali būti vienodi eilės {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +243,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Skirtumas paskyra turi būti turto / įsipareigojimų tipo sąskaita, nes tai sandėlyje Susitaikymas yra atidarymas įrašas"
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107,Disbursed Amount cannot be greater than Loan Amount {0},Išmokėta suma negali būti didesnis nei paskolos suma {0}
apps/erpnext/erpnext/utilities/user_progress.py +173,Go to Programs,Eikite į &quot;Programos&quot;
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +219,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Eilutė {0} # paskirstyta suma {1} negali būti didesnė nei nepageidaujama suma {2}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89,Purchase Order number required for Item {0},"Pirkimo užsakymo numerį, reikalingą punkto {0}"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +943,Production Order not created,Gamybos Kad nebūtų sukurta
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date',&quot;Nuo data&quot; turi būti po &quot;Iki datos&quot;
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39,Cannot change status as student {0} is linked with student application {1},Nepavyksta pakeisti statusą kaip studentas {0} yra susijęs su studento taikymo {1}
DocType: Asset,Fully Depreciated,visiškai nusidėvėjusi
,Stock Projected Qty,Akcijų Numatoma Kiekis
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +431,Customer {0} does not belong to project {1},Klientų {0} nepriklauso projekto {1}
DocType: Employee Attendance Tool,Marked Attendance HTML,Pažymėti Lankomumas HTML
apps/erpnext/erpnext/utilities/activation.py +73,"Quotations are proposals, bids you have sent to your customers","Citatos yra pasiūlymų, pasiūlymai turite atsiųsti savo klientams"
DocType: Sales Order,Customer's Purchase Order,Kliento Užsakymo
DocType: Consultation,Patient,Pacientas
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Bypass credit check at Sales Order ,Atidaryti kredito patikrą Pardavimų užsakymas
DocType: Land Unit,Check if it is a hydroponic unit,"Patikrinkite, ar tai hidroponinis blokas"
apps/erpnext/erpnext/config/stock.py +109,Serial No and Batch,Serijos Nr paketais
DocType: Warranty Claim,From Company,iš Company
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +52,Sum of Scores of Assessment Criteria needs to be {0}.,Suma balais vertinimo kriterijai turi būti {0}.
apps/erpnext/erpnext/assets/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,Prašome nustatyti Taškų nuvertinimai Užsakytas
DocType: Supplier Scorecard Period,Calculations,Skaičiavimai
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +89,Value or Qty,Vertė arba Kiekis
DocType: Payment Terms Template,Payment Terms,Mokėjimo sąlygos
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +426,Productions Orders cannot be raised for:,Productions pavedimai negali būti padidinta:
apps/erpnext/erpnext/utilities/user_progress.py +144,Minute,Minutė
DocType: Purchase Invoice,Purchase Taxes and Charges,Pirkimo mokesčius bei rinkliavas
DocType: Chapter,Meetup Embed HTML,&quot;Embedup&quot; HTML įvestis
apps/erpnext/erpnext/utilities/user_progress.py +118,Go to Suppliers,Eikite į tiekėjus
,Qty to Receive,Kiekis Gavimo
DocType: Leave Block List,Leave Block List Allowed,Palikite Blokuoti sąrašas Leido
DocType: Grading Scale Interval,Grading Scale Interval,Rūšiavimas padalos
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49,Expense Claim for Vehicle Log {0},Kompensuojamos Prašymas Transporto Prisijungti {0}
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Nuolaida (%) nuo Kainų sąrašas norma atsargos
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Nuolaida (%) nuo Kainų sąrašas norma atsargos
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,Visi Sandėliai
DocType: Sales Partner,Retailer,mažmenininkas
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115,Credit To account must be a Balance Sheet account,Kreditas sąskaitos turi būti balansas sąskaitos
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +122,All Supplier Types,Visi Tiekėjo tipai
DocType: Donor,Donor,Donoras
DocType: Global Defaults,Disable In Words,Išjungti žodžiais
apps/erpnext/erpnext/stock/doctype/item/item.py +49,Item Code is mandatory because Item is not automatically numbered,"Prekės kodas yra privalomas, nes prekės nėra automatiškai sunumeruoti"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98,Quotation {0} not of type {1},Citata {0} nėra tipo {1}
DocType: Maintenance Schedule Item,Maintenance Schedule Item,Priežiūra Tvarkaraštis punktas
DocType: Sales Order,%  Delivered,% Pristatyta
apps/erpnext/erpnext/education/doctype/fees/fees.js +105,Please set the Email ID for the Student to send the Payment Request,"Nustatykite studento elektroninio pašto adresą, kad atsiųstumėte mokėjimo užklausą"
DocType: Production Order,PRO-,PRO-
DocType: Patient,Medical History,Medicinos istorija
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157,Bank Overdraft Account,Bankas Overdraftas paskyra
DocType: Patient,Patient ID,Paciento ID
DocType: Physician Schedule,Schedule Name,Tvarkaraščio pavadinimas
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48,Make Salary Slip,Padaryti darbo užmokestį
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +838,Add All Suppliers,Pridėti visus tiekėjus
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +83,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Eilutė # {0}: Paskirstytas suma gali būti ne didesnis nei likutinę sumą.
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75,Browse BOM,Žmonės BOM
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,Secured Loans,užtikrintos paskolos
DocType: Purchase Invoice,Edit Posting Date and Time,Redaguoti Siunčiamos data ir laikas
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Prašome nustatyti Nusidėvėjimas susijusias sąskaitas Turto kategorija {0} ar kompanija {1}
DocType: Lab Test Groups,Normal Range,Normalus diapazonas
DocType: Academic Term,Academic Year,Mokslo metai
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Available Selling,Galima parduoti
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169,Opening Balance Equity,Atidarymas Balansas Akcijų
DocType: Lead,CRM,CRM
DocType: Purchase Invoice,N,N
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,likęs
DocType: Appraisal,Appraisal,įvertinimas
DocType: Purchase Invoice,GST Details,GST duomenys
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +154,Email sent to supplier {0},Paštas išsiųstas tiekėjo {0}
DocType: Item,Default Sales Unit of Measure,Numatytasis pardavimų matavimo vienetas
DocType: Opportunity,OPTY-,OPTY-
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,Data kartojamas
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,Įgaliotas signataras
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +215,Leave approver must be one of {0},Palikite Tvirtintojas turi būti vienas iš {0}
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +67,Create Fees,Sukurkite mokesčius
DocType: Project,Total Purchase Cost (via Purchase Invoice),Viso įsigijimo savikainą (per pirkimo sąskaitoje faktūroje)
DocType: Training Event,Start Time,Pradžios laikas
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +400,Select Quantity,Pasirinkite Kiekis
DocType: Customs Tariff Number,Customs Tariff Number,Muitų tarifo numeris
DocType: Patient Appointment,Patient Appointment,Paciento paskyrimas
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,Patvirtinimo vaidmuo gali būti ne tas pats kaip vaidmens taisyklė yra taikoma
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +64,Unsubscribe from this Email Digest,Atsisakyti Šis el.pašto Digest
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +828,Get Suppliers By,Gaukite tiekėjų
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +170,{0} not found for Item {1},{0} nerasta {1} elementui
apps/erpnext/erpnext/utilities/user_progress.py +194,Go to Courses,Eikite į kursus
DocType: Accounts Settings,Show Inclusive Tax In Print,Rodyti inkliuzinį mokestį spausdinant
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,Žinutė išsiųsta
apps/erpnext/erpnext/accounts/doctype/account/account.py +98,Account with child nodes cannot be set as ledger,Sąskaita su vaikų mazgų negali būti nustatyti kaip knygoje
DocType: C-Form,II,II
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Norma, pagal kurią Kainoraštis valiuta konvertuojama į kliento bazine valiuta"
DocType: Purchase Invoice Item,Net Amount (Company Currency),Grynasis kiekis (Įmonės valiuta)
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +229,Total advance amount cannot be greater than total sanctioned amount,Bendra avanso suma negali būti didesnė už visą sankcionuotą sumą
DocType: Salary Slip,Hour Rate,valandą greičiu
DocType: Stock Settings,Item Naming By,Prekė Pavadinimų Iki
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46,Another Period Closing Entry {0} has been made after {1},Kitas Laikotarpis uždarymas Įėjimas {0} buvo padaryta po {1}
DocType: Production Order,Material Transferred for Manufacturing,"Medžiagos, perduotos gamybos"
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +37,Account {0} does not exists,Sąskaita {0} neegzistuoja
DocType: Project,Project Type,projekto tipas
apps/erpnext/erpnext/projects/doctype/task/task.py +142,Child Task exists for this Task. You can not delete this Task.,Ši užduotis yra vaiko užduotis. Negalite ištrinti šios užduotys.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16,Either target qty or target amount is mandatory.,Bet tikslas Kiekis arba planuojama suma yra privalomas.
apps/erpnext/erpnext/hub_node/page/hub/hub.js +731,No more results,Daugiau rezultatų nebebus
apps/erpnext/erpnext/config/projects.py +51,Cost of various activities,Išlaidos įvairiose veiklos
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}","Nustatymas įvykių {0}, nes pridedamas prie žemiau pardavėjai darbuotojas neturi naudotojo ID {1}"
DocType: Timesheet,Billing Details,Atsiskaitymo informacija
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +155,Source and target warehouse must be different,Originalo ir vertimo sandėlis turi skirtis
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},Neleidžiama atnaujinti akcijų sandorius senesnis nei {0}
DocType: Purchase Invoice Item,PR Detail,PR detalės
DocType: Driving License Category,Class,Klasė
DocType: Sales Order,Fully Billed,pilnai Įvardintas
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101,Shipping rule only applicable for Buying,Pristatymo taisyklė taikoma tik pirkimui
DocType: Vital Signs,BMI,KMI
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Grynieji pinigai kasoje
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137,Delivery warehouse required for stock item {0},Pristatymas sandėlis reikalingas akcijų punkte {0}
DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Bendras svoris pakuotės. Paprastai neto masė + pakavimo medžiagos svorio. (Spausdinimo)
DocType: Assessment Plan,Program,programa
DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,"Vartotojai, turintys šį vaidmenį yra leidžiama nustatyti įšaldytas sąskaitas ir sukurti / pakeisti apskaitos įrašus prieš įšaldytų sąskaitų"
DocType: Serial No,Is Cancelled,Ar atšauktas
DocType: Student Group,Group Based On,Grupė remiantis
DocType: Student Group,Group Based On,Grupė remiantis
DocType: Journal Entry,Bill Date,Billas data
DocType: Healthcare Settings,Laboratory SMS Alerts,Laboratoriniai SMS perspėjimai
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20,"Service Item,Type,frequency and expense amount are required","Paslaugų Punktas, tipas, dažnis ir išlaidų suma yra privalomi"
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:","Net jei yra keli kainodaros taisyklės, kurių didžiausias prioritetas, tada šie vidiniai prioritetai taikomi:"
DocType: Plant Analysis Criteria,Plant Analysis Criteria,Augalų analizės kriterijai
DocType: Cheque Print Template,Cheque Height,Komunalinės Ūgis
DocType: Supplier,Supplier Details,Tiekėjo informacija
DocType: Setup Progress,Setup Progress,&quot;Progress setup&quot;
DocType: Expense Claim,Approval Status,patvirtinimo būsena
DocType: Hub Settings,Publish Items to Hub,Publikuoti prekę į Hub
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35,From value must be less than to value in row {0},Nuo vertė turi būti mažesnė nei vertės eilės {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182,Wire Transfer,pavedimu
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92,Check all,Viską Patikrink
DocType: Vehicle Log,Invoice Ref,Sąskaitos faktūros Nuoroda
DocType: Company,Default Income Account,Numatytasis pajamų sąskaita
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32,Customer Group / Customer,Klientų grupė / Klientų
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37,Unclosed Fiscal Years Profit / Loss (Credit),Neuždara fiskalinių metų pelnas / nuostolis (kreditas)
DocType: Sales Invoice,Time Sheets,darbo laiko apskaitos žiniaraščiai
DocType: Lab Test Template,Change In Item,Pakeisti prekę
DocType: Payment Gateway Account,Default Payment Request Message,Numatytąjį mokėjimo prašymas pranešimas
DocType: Item Group,Check this if you want to show in website,"Pažymėkite, jei norite parodyti svetainėje"
apps/erpnext/erpnext/config/accounts.py +134,Banking and Payments,Bankininkystė ir mokėjimai
,Welcome to ERPNext,Sveiki atvykę į ERPNext
apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Švinas su citavimo
DocType: Patient,A Negative,Neigiamas
apps/erpnext/erpnext/templates/includes/product_list.js +45,Nothing more to show.,Nieko daugiau parodyti.
DocType: Lead,From Customer,nuo Klientui
apps/erpnext/erpnext/demo/setup/setup_data.py +327,Calls,ragina
apps/erpnext/erpnext/utilities/user_progress.py +140,A Product,Produktas
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207,Batches,partijos
apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Padaryti mokestį
DocType: Purchase Order Item Supplied,Stock UOM,akcijų UOM
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233,Purchase Order {0} is not submitted,Pirkimui užsakyti {0} nebus pateiktas
DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Suaugusioji normali referencinė diapazona yra 16-20 kvėpavimo takų per minutę (RCP 2012)
DocType: Customs Tariff Number,Tariff Number,tarifas Taškų
DocType: Production Order Item,Available Qty at WIP Warehouse,Turimas Kiekis ne WIP Warehouse
apps/erpnext/erpnext/stock/doctype/item/item.js +39,Projected,prognozuojama
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222,Serial No {0} does not belong to Warehouse {1},Serijos Nr {0} nepriklauso sandėlis {1}
apps/erpnext/erpnext/controllers/status_updater.py +174,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Pastaba: sistema netikrins per pristatymą ir per metu už prekę {0} kaip kiekis ar visa suma yra 0
DocType: Notification Control,Quotation Message,citata pranešimas
DocType: Employee Loan,Employee Loan Application,Darbuotojų paraišką paskolai gauti
DocType: Issue,Opening Date,atidarymo data
apps/erpnext/erpnext/education/api.py +80,Attendance has been marked successfully.,Žiūrovų buvo pažymėta sėkmingai.
DocType: Program Enrollment,Public Transport,Viešasis transportas
DocType: Soil Texture,Silt Composition (%),Stiklo sudėtis (%)
DocType: Journal Entry,Remark,pastaba
DocType: Healthcare Settings,Avoid Confirmation,Venkite patvirtinimo
DocType: Purchase Receipt Item,Rate and Amount,Norma ir dydis
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +165,Account Type for {0} must be {1},"Sąskaitos tipas {0}, turi būti {1}"
DocType: Healthcare Settings,Default income accounts to be used if not set in Physician to book Consultation charges.,"Numatytoji pajamų sąskaita, kuri turi būti naudojama, jei nenustatyta Gydytojas, norėdamas užsisakyti konsultacijų mokesčius."
apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Lapai ir poilsis
DocType: Education Settings,Current Academic Term,Dabartinis akademinės terminas
DocType: Education Settings,Current Academic Term,Dabartinis akademinės terminas
DocType: Sales Order,Not Billed,ne Įvardintas
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +77,Both Warehouse must belong to same Company,Tiek Sandėlis turi priklausyti pati bendrovė
apps/erpnext/erpnext/public/js/templates/contact_list.html +34,No contacts added yet.,pridėjo dar neturi kontaktai.
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Nusileido kaina kupono suma
apps/erpnext/erpnext/config/accounts.py +17,Bills raised by Suppliers.,Vekseliai iškelti tiekėjų.
DocType: POS Profile,Write Off Account,Nurašyti paskyrą
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +89,Debit Note Amt,Debeto aviza Amt
apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,Discount Amount,Nuolaida suma
DocType: Purchase Invoice,Return Against Purchase Invoice,Grįžti Against pirkimo faktūros
DocType: Item,Warranty Period (in days),Garantinis laikotarpis (dienomis)
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61,Failed to set defaults,Nepavyko nustatyti numatytuosius nustatymus
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Ryšys su Guardian1
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +797,Please select BOM against item {0},Pasirinkite BOM dėl elemento {0}
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18,Make Invoices,Padaryti sąskaitas faktūras
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +18,Net Cash from Operations,Grynieji pinigų srautai iš įprastinės veiklos
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,4 punktas
DocType: Student Admission,Admission End Date,Priėmimo Pabaigos data
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30,Sub-contracting,Subrangovai
DocType: Journal Entry Account,Journal Entry Account,Leidinys sumokėjimas
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3,Student Group,Studentų grupė
DocType: Shopping Cart Settings,Quotation Series,citata serija
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +56,"An item exists with same name ({0}), please change the item group name or rename the item","Elementas egzistuoja to paties pavadinimo ({0}), prašome pakeisti elementą grupės pavadinimą ar pervardyti elementą"
DocType: Soil Analysis Criteria,Soil Analysis Criteria,Dirvožemio analizės kriterijai
apps/erpnext/erpnext/accounts/page/pos/pos.js +2021,Please select customer,Prašome pasirinkti klientui
DocType: C-Form,I,aš
DocType: Company,Asset Depreciation Cost Center,Turto nusidėvėjimo išlaidos centras
DocType: Sales Order Item,Sales Order Date,Pardavimų užsakymų data
DocType: Sales Invoice Item,Delivered Qty,Paskelbta Kiekis
DocType: Production Planning Tool,"If checked, all the children of each production item will be included in the Material Requests.","Jei pažymėta, visi kiekvienos gamybos prekės vaikai bus įtraukti į Materialiųjų prašymus."
DocType: Assessment Plan,Assessment Plan,vertinimo planas
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +93,Customer {0} is created.,Klientas {0} sukurtas.
DocType: Stock Settings,Limit Percent,riba procentais
apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,Prašome nustatyti &quot;Instruktorių pavadinimo&quot; sistemą &quot;Education&quot;&gt; &quot;Education Settings&quot;
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,Šiuo metu sandėlyje nėra sandėlyje
,Payment Period Based On Invoice Date,Mokėjimo periodas remiantis sąskaitos faktūros išrašymo data
DocType: Sample Collection,No. of print,Spaudos numeris
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58,Missing Currency Exchange Rates for {0},Trūksta Valiutų kursai už {0}
DocType: Assessment Plan,Examiner,egzaminuotojas
DocType: Student,Siblings,broliai ir seserys
DocType: Journal Entry,Stock Entry,"atsargų,"
DocType: Payment Entry,Payment References,Apmokėjimo Nuorodos
DocType: C-Form,C-FORM-,", C-FORM-"
DocType: Vehicle,Insurance Details,draudimo detalės
DocType: Account,Payable,mokėtinas
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113,Please enter Repayment Periods,Prašome įvesti grąžinimo terminams
apps/erpnext/erpnext/shopping_cart/cart.py +375,Debtors ({0}),Skolininkai ({0})
DocType: Pricing Rule,Margin,marža
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Nauji klientai
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Gross Profit %,Bendrasis pelnas %
DocType: Appraisal Goal,Weightage (%),Weightage (%)
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +496,Change POS Profile,Keisti POS profilį
DocType: Bank Reconciliation Detail,Clearance Date,Sąskaitų data
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Vertinimo ataskaita
apps/erpnext/erpnext/assets/doctype/asset/asset.py +59,Gross Purchase Amount is mandatory,Pilna Pirkimo suma yra privalomi
DocType: Lead,Address Desc,Adresas desc
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +102,Party is mandatory,Šalis yra privalomi
DocType: Journal Entry,JV-,JV-
apps/erpnext/erpnext/controllers/accounts_controller.py +707,Rows with duplicate due dates in other rows were found: {list},Rastos su dviem egzemplioriais nurodytų datų kitose eilutėse buvo rasta: {list}
DocType: Topic,Topic Name,Temos pavadinimas
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +36,Atleast one of the Selling or Buying must be selected,"Atleast vienas, pardavimas arba pirkimas turi būti parenkamas"
apps/erpnext/erpnext/public/js/setup_wizard.js +36,Select the nature of your business.,Pasirinkite savo verslo pobūdį.
DocType: Lab Test Template,"Single for results which require only a single input, result UOM and normal value 
<br>
Compound for results which require multiple input fields with corresponding event names, result UOMs and normal values
<br>
Descriptive for tests which have multiple result components and corresponding result entry fields. 
<br>
Grouped for test templates which are a group of other test templates.
<br>
No Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.","Vienintelis rezultatams, kuriems reikalingas tik vienas įvestis, rezultatas UOM ir normalioji vertė <br> Sudėtis, skirta rezultatams, kuriems reikalingi keli įvesties laukai su atitinkamais įvykių pavadinimais, rezultatų UOM ir normaliomis vertėmis <br> Aprašomi bandymai, turintys keletą rezultatų sudedamųjų dalių ir atitinkamų rezultatų įrašymo laukų. <br> Grupuojami bandymo šablonai, kurie yra kitų bandymų šablonų grupė. <br> Rezultatų nėra, nes rezultatų nėra. Be to, nėra sukurtas laboratorinis testas. pvz. Sub-bandymai grupuotiems rezultatams."
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +75,Row #{0}: Duplicate entry in References {1} {2},Eilutė # {0}: pasikartojantis įrašas nuorodose {1} {2}
apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,Kur gamybos operacijos atliekamos.
apps/erpnext/erpnext/education/doctype/instructor/instructor.js +18,As Examiner,Kaip egzaminuotojas
DocType: Asset Movement,Source Warehouse,šaltinis sandėlis
DocType: Installation Note,Installation Date,Įrengimas data
apps/erpnext/erpnext/controllers/accounts_controller.py +605,Row #{0}: Asset {1} does not belong to company {2},Eilutės # {0}: Turto {1} nepriklauso bendrovei {2}
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206,Sales Invoice {0} created,Sukurta pardavimo sąskaitą {0}
DocType: Employee,Confirmation Date,Patvirtinimas data
DocType: C-Form,Total Invoiced Amount,Iš viso Sąskaitoje suma
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +49,Min Qty can not be greater than Max Qty,Min Kiekis negali būti didesnis nei Max Kiekis
DocType: Soil Texture,Silty Clay,Šilkinis molis
DocType: Account,Accumulated Depreciation,sukauptas nusidėvėjimas
DocType: Supplier Scorecard Scoring Standing,Standing Name,Nuolatinis vardas
DocType: Stock Entry,Customer or Supplier Details,Klientas ar tiekėjas detalės
DocType: Employee Loan Application,Required by Date,Reikalauja data
DocType: Lead,Lead Owner,Švinas autorius
DocType: Bin,Requested Quantity,prašomam kiekiui
DocType: Patient,Marital Status,Šeimyninė padėtis
DocType: Stock Settings,Auto Material Request,Auto Medžiaga Prašymas
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Turimas Serija Kiekis ne iš sandėlio
DocType: Customer,CUST-,CUST-
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Pilna darbo užmokestis - Iš viso išskaičiavimas - Paskolų grąžinimas
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +26,Current BOM and New BOM can not be same,Dabartinis BOM ir Naujoji BOM negali būti tas pats
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +45,Salary Slip ID,Pajamos Kuponas ID
apps/erpnext/erpnext/hr/doctype/employee/employee.py +118,Date Of Retirement must be greater than Date of Joining,Data nuo išėjimo į pensiją turi būti didesnis nei įstoti data
apps/erpnext/erpnext/stock/doctype/item/item.js +68,Multiple Variants,Keli variantai
DocType: Sales Invoice,Against Income Account,Prieš pajamų sąskaita
apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% Paskelbta
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +103,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Prekė {0}: Užsakytas Kiekis {1} negali būti mažesnis nei minimalus užsakymo Kiekis {2} (apibrėžtą punktas).
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Mėnesio pasiskirstymas procentais
apps/erpnext/erpnext/hub_node/page/hub/hub.js +90,Please login as another user.,Prašau prisijungti kaip kitas vartotojas.
DocType: Territory,Territory Targets,Teritorija tikslai
DocType: Soil Analysis,Ca/Mg,Ca / Mg
DocType: Delivery Note,Transporter Info,transporteris Informacija
apps/erpnext/erpnext/accounts/utils.py +502,Please set default {0} in Company {1},Prašome nustatyti numatytąjį {0} įmonėje {1}
DocType: Cheque Print Template,Starting position from top edge,Pradinė padėtis nuo viršaus
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +31,Same supplier has been entered multiple times,Tas pats tiekėjas buvo įrašytas kelis kartus
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Bendrasis pelnas / nuostolis
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Pirkimui užsakyti punktas Pateikiamas
apps/erpnext/erpnext/public/js/setup_wizard.js +94,Company Name cannot be Company,Įmonės pavadinimas negali būti Įmonės
apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Laiškas vadovai dėl spausdinimo šablonus.
apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,Pavadinimus spausdinimo šablonų pvz išankstinio mokėjimo sąskaitą.
DocType: Program Enrollment,Walking,vaikščiojimas
DocType: Student Guardian,Student Guardian,Studentų globėjas
DocType: Member,Member Name,Nario vardas
DocType: Stock Settings,Use Naming Series,Naudokite vardų seriją
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218,Valuation type charges can not marked as Inclusive,Vertinimo tipas mokesčiai negali pažymėta kaip įskaičiuota
DocType: POS Profile,Update Stock,Atnaujinti sandėlyje
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,in the subscription,prenumeruojant
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.,"Įvairūs UOM daiktų bus neteisinga (iš viso) Grynasis svoris vertės. Įsitikinkite, kad grynasis svoris kiekvieno elemento yra toje pačioje UOM."
DocType: Membership,Payment Details,Mokėjimo detalės
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,BOM Balsuok
DocType: Asset,Journal Entry for Scrap,Žurnalo įrašą laužo
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83,Please pull items from Delivery Note,Prašome traukti elementus iš važtaraštyje
apps/erpnext/erpnext/accounts/utils.py +472,Journal Entries {0} are un-linked,Žurnalas įrašai {0} yra JT susietų
apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.","Įrašų visų tipo paštu, telefonu, pokalbiai, apsilankymo, ir tt ryšių"
DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Tiekėjo rezultatų vertinimo lentelė
DocType: Manufacturer,Manufacturers used in Items,Gamintojai naudojami daiktai
apps/erpnext/erpnext/accounts/general_ledger.py +168,Please mention Round Off Cost Center in Company,Paminėkite suapvalinti sąnaudų centro įmonėje
DocType: Purchase Invoice,Terms,sąlygos
DocType: Academic Term,Term Name,terminas Vardas
DocType: Buying Settings,Purchase Order Required,Pirkimui užsakyti Reikalinga
,Item-wise Sales History,Prekė išmintingas Pardavimų istorija
DocType: Expense Claim,Total Sanctioned Amount,Iš viso sankcijos suma
DocType: Land Unit,Land Unit,Žemės vienetas
,Purchase Analytics,pirkimo Analytics &quot;
DocType: Sales Invoice Item,Delivery Note Item,Važtaraštis punktas
DocType: Asset Maintenance Log,Task,užduotis
DocType: Purchase Taxes and Charges,Reference Row #,Nuoroda eilutė #
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76,Batch number is mandatory for Item {0},Partijos numeris yra privalomas punktas {0}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13,This is a root sales person and cannot be edited.,Tai yra šaknų pardavimo asmuo ir negali būti pakeisti.
DocType: Salary Detail,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Jei pasirinkta, nenurodyti arba apskaičiuojama šio komponento vertė nebus prisidedama prie savo uždarbio ar atskaitymų. Tačiau, tai vertė gali būti nurodoma kitų komponentų, kurie gali būti pridedamos arba atimamos."
DocType: Salary Detail,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Jei pasirinkta, nenurodyti arba apskaičiuojama šio komponento vertė nebus prisidedama prie savo uždarbio ar atskaitymų. Tačiau, tai vertė gali būti nurodoma kitų komponentų, kurie gali būti pridedamos arba atimamos."
,Stock Ledger,akcijų Ledgeris
apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Balsuok: {0}
DocType: Company,Exchange Gain / Loss Account,Valiutų Pelnas / nuostolis paskyra
apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Darbuotojų ir lankymas
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +88,Purpose must be one of {0},Tikslas turi būti vienas iš {0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +116,Fill the form and save it,Užpildykite formą ir išsaugokite jį
DocType: Production Planning Tool,Download a report containing all raw materials with their latest inventory status,"Atsisiųskite ataskaitą, kurioje visų žaliavų su savo naujausia inventoriaus būklę"
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Bendruomenė Forumas
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52,Actual qty in stock,Tikrasis Kiekis sandėlyje
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52,Actual qty in stock,Tikrasis Kiekis sandėlyje
DocType: Homepage,"URL for ""All Products""",URL &quot;Visi produktai&quot;
DocType: Leave Application,Leave Balance Before Application,Palikite balansas Prieš taikymas
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +46,Send SMS,siųsti SMS
DocType: Supplier Scorecard Criteria,Max Score,Didžiausias balas
DocType: Cheque Print Template,Width of amount in word,Plotis suma žodžiu
DocType: Company,Default Letter Head,Numatytasis raštas vadovas
DocType: Purchase Order,Get Items from Open Material Requests,Gauk daiktai iš atvirų Materialiųjų Prašymai
DocType: Lab Test Template,Standard Selling Rate,Standartinė pardavimo kursą
DocType: Account,Rate at which this tax is applied,"Norma, kuri yra taikoma ši mokesčių"
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +75,Reorder Qty,Pertvarkyti Kiekis
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28,Current Job Openings,Dabartinis darbas Angos
DocType: Company,Stock Adjustment Account,Vertybinių popierių reguliavimas paskyra
apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,Nusirašinėti
DocType: Timesheet Detail,Operation ID,operacija ID
DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","Sistemos vartotojas (Prisijunk) adresas. Jei nustatyta, ji taps nutylėjimą visiems HR formas."
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}: Nuo {1}
DocType: Task,depends_on,priklauso nuo
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +49,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Kviečiame atnaujinti naujausią kainą visame medžiagų sąraše. Tai gali užtrukti kelias 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,Pavadinimas naują paskyrą. Pastaba: nekurkite sąskaitas klientai ir tiekėjai
apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Šalis protinga numatytasis adresas Šablonai
DocType: Water Analysis,Appearance,Išvaizda
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Buying Price List Rate,Vidur. Pirkimo kainų sąrašo norma
DocType: Sales Order Item,Supplier delivers to Customer,Tiekėjas pristato Klientui
apps/erpnext/erpnext/config/non_profit.py +23,Member information.,Nario informacija.
apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Forma / Prekės / {0}) yra sandelyje
apps/erpnext/erpnext/assets/doctype/asset/asset.js +58,Asset Maintenance,Turto priežiūra
,Sales Payment Summary,Pardavimų mokėjimo suvestinė
DocType: Restaurant,Restaurant,Restoranas
apps/erpnext/erpnext/accounts/party.py +323,Due / Reference Date cannot be after {0},Dėl / Nuoroda data negali būti po {0}
apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Duomenų importas ir eksportas
DocType: Patient,Account Details,Išsami paskyros informacija
DocType: Crop,Materials Required,Reikalingos medžiagos
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76,No students Found,Studentai Surasta
DocType: Medical Department,Medical Department,Medicinos skyrius
DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Tiekėjo vertinimo rezultatų vertinimo kriterijai
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55,Invoice Posting Date,Sąskaita Siunčiamos data
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,Parduoti
DocType: Purchase Invoice,Rounded Total,Suapvalinta bendra suma
DocType: Product Bundle,List items that form the package.,"Sąrašas daiktų, kurie sudaro paketą."
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Procentas paskirstymas turi būti lygus 100%
DocType: Crop Cycle,Linked Land Unit,Susijusios žemės vienetas
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584,Please select Posting Date before selecting Party,Prašome pasirinkti Skelbimo data prieš pasirinkdami Šaliai
DocType: Program Enrollment,School House,Mokykla Namas
DocType: Serial No,Out of AMC,Iš AMC
apps/erpnext/erpnext/assets/doctype/asset/asset.py +82,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Taškų nuvertinimai REZERVUOTA negali būti didesnis nei bendras skaičius nuvertinimai
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Padaryti Priežiūros vizitas
apps/erpnext/erpnext/selling/doctype/customer/customer.py +199,Please contact to the user who have Sales Master Manager {0} role,"Prašome susisiekti su vartotojo, kuris turi pardavimo magistras Manager {0} vaidmenį"
DocType: Company,Default Cash Account,Numatytasis pinigų sąskaitos
apps/erpnext/erpnext/config/accounts.py +62,Company (not Customer or Supplier) master.,Įmonės (ne klientas ar tiekėjas) meistras.
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,"Tai yra, remiantis šio mokinių lankomumą"
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Nėra Studentai
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +171,Add more items or open full form,Pridėti daugiau elementų arba atidaryti visą formą
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Pristatymo Pastabos {0} turi būti atšauktas prieš panaikinant šį pardavimo užsakymų
apps/erpnext/erpnext/utilities/user_progress.py +256,Go to Users,Eikite į &quot;Vartotojai&quot;
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,Paid amount + Write Off Amount can not be greater than Grand Total,Mokama suma + nurašyti suma negali būti didesnė nei IŠ VISO
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,{0} is not a valid Batch Number for Item {1},{0} yra neteisingas SERIJOS NUMERIS už prekę {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +149,Note: There is not enough leave balance for Leave Type {0},Pastaba: Nėra pakankamai atostogos balansas Palikti tipas {0}
apps/erpnext/erpnext/regional/india/utils.py +16,Invalid GSTIN or Enter NA for Unregistered,Neteisingas GSTIN ar Įveskite NA neregistruotas
DocType: Training Event,Seminar,seminaras
DocType: Program Enrollment Fee,Program Enrollment Fee,Programos Dalyvio mokestis
DocType: Item,Supplier Items,Tiekėjo daiktai
DocType: Opportunity,Opportunity Type,galimybė tipas
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16,New Company,nauja Įmonės
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17,Transactions can only be deleted by the creator of the Company,Sandoriai gali būti išbraukta tik Bendrovės kūrėjo
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.,Neteisingas skaičius didžiąją knygą Įrašai nerasta. Galbūt pasirinkote neteisingą sąskaitą sandoryje.
DocType: Employee,Prefered Contact Email,Pageidaujamas Kontaktai El.paštas
DocType: Cheque Print Template,Cheque Width,Komunalinės Plotis
DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Patvirtinti pardavimo kaina už prekę prieš Pirkimo rodikliu Vertinimo koeficientas
DocType: Fee Schedule,Fee Schedule,mokestis Tvarkaraštis
DocType: Hub Settings,Publish Availability,Paskelbti Prieinamumas
DocType: Company,Create Chart Of Accounts Based On,Sukurti sąskaitų planą remiantis
apps/erpnext/erpnext/projects/doctype/task/task.js +91,Cannot convert it to non-group. Child Tasks exist.,Negalima konvertuoti į ne grupę. Vaikų užduotys egzistuoja.
apps/erpnext/erpnext/hr/doctype/employee/employee.py +112,Date of Birth cannot be greater than today.,Gimimo data negali būti didesnis nei dabar.
,Stock Ageing,akcijų senėjimas
apps/erpnext/erpnext/education/doctype/student/student.py +38,Student {0} exist against student applicant {1},Studentų {0} egzistuoja nuo studento pareiškėjo {1}
DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Apvalinimo koregavimas (įmonės valiuta)
apps/erpnext/erpnext/projects/doctype/task/task.js +39,Timesheet,darbo laiko apskaitos žiniaraštis
DocType: Volunteer,Afternoon,Popietė
apps/erpnext/erpnext/controllers/accounts_controller.py +257,{0} '{1}' is disabled,{0} &quot;{1}&quot; yra išjungta
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Nustatyti kaip Open
DocType: Cheque Print Template,Scanned Cheque,Nuskaityti čekis
DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,"Siųsti automatinius laiškus Kontaktai, kaip pateikti sandorių."
DocType: Timesheet,Total Billable Amount,Iš viso Apmokestinama suma
DocType: Customer,Credit Limit and Payment Terms,Kredito limitas ir mokėjimo sąlygos
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,3 punktas
apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6,Order Entry,Užsakymo įrašas
DocType: Purchase Order,Customer Contact Email,Klientų Kontaktai El.paštas
DocType: Warranty Claim,Item and Warranty Details,Punktas ir garantijos informacija
DocType: Chapter,Chapter Members,Skyrius nariai
DocType: Sales Team,Contribution (%),Indėlis (%)
apps/erpnext/erpnext/controllers/accounts_controller.py +101,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Pastaba: mokėjimo įrašas nebus sukurtos nuo &quot;pinigais arba banko sąskaitos&quot; nebuvo nurodyta
apps/erpnext/erpnext/projects/doctype/project/project.py +67,Project {0} already exists,Projektas {0} jau egzistuoja
DocType: Medical Department,Nursing User,Slaugos naudotojas
DocType: Plant Analysis,Plant Analysis Criterias,Augalų analizės kriterijai
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +237,Responsibilities,atsakomybė
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125,Validity period of this quotation has ended.,Pasibaigė šios citatos galiojimo laikotarpis.
DocType: Expense Claim Account,Expense Claim Account,Kompensuojamos Pretenzija paskyra
DocType: Accounts Settings,Allow Stale Exchange Rates,Leisti nejudančius valiutų keitimo kursus
DocType: Sales Person,Sales Person Name,Pardavimų Asmuo Vardas
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,Prašome įvesti atleast 1 sąskaitą lentelėje
apps/erpnext/erpnext/utilities/user_progress.py +244,Add Users,Pridėti Vartotojai
DocType: POS Item Group,Item Group,Prekė grupė
DocType: Item,Safety Stock,saugos kodas
DocType: Healthcare Settings,Healthcare Settings,Sveikatos priežiūros nustatymai
apps/erpnext/erpnext/projects/doctype/task/task.py +54,Progress % for a task cannot be more than 100.,Pažanga% užduoties negali būti daugiau nei 100.
DocType: Stock Reconciliation Item,Before reconciliation,prieš susitaikymo
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12,To {0},Norėdami {0}
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Mokesčiai ir rinkliavos Pridėta (Įmonės valiuta)
apps/erpnext/erpnext/stock/doctype/item/item.py +461,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Prekė Mokesčių eilutė {0} turi atsižvelgti tipo mokesčio ar pajamų ar sąnaudų arba Apmokestinimo
DocType: Sales Order,Partly Billed,dalinai Įvardintas
apps/erpnext/erpnext/assets/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Prekė {0} turi būti ilgalaikio turto
apps/erpnext/erpnext/stock/doctype/item/item.js +341,Make Variants,Padaryti variantus
DocType: Item,Default BOM,numatytasis BOM
DocType: Project,Total Billed Amount (via Sales Invoices),Visa išleista suma (per pardavimo sąskaitas faktūras)
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Debit Note Amount,Debeto Pastaba suma
apps/erpnext/erpnext/setup/doctype/company/company.js +89,Please re-type company name to confirm,Prašome iš naujo tipo įmonės pavadinimas patvirtinti
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +90,Total Outstanding Amt,Visos negrąžintos Amt
DocType: Journal Entry,Printing Settings,Spausdinimo nustatymai
DocType: Employee Advance,Advance Account,Išankstinė sąskaita
DocType: Sales Invoice,Include Payment (POS),Įtraukti mokėjimą (POS)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +290,Total Debit must be equal to Total Credit. The difference is {0},Iš viso debetas turi būti lygus Kreditai. Skirtumas yra {0}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11,Automotive,Automobiliai
DocType: Vehicle,Insurance Company,Draudimo bendrovė
DocType: Asset Category Account,Fixed Asset Account,Ilgalaikio turto sąskaita
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414,Variable,kintamas
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Nuo važtaraštyje
DocType: Chapter,Members,Nariai
DocType: Student,Student Email Address,Studentų elektroninio pašto adresas
DocType: Item,Hub Warehouse,&quot;Hub&quot; sandėlis
DocType: Assessment Plan,From Time,nuo Laikas
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock: ,Prekyboje:
DocType: Notification Control,Custom Message,Pasirinktinis pranešimas
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33,Investment Banking,Investicinės bankininkystės
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79,Cash or Bank Account is mandatory for making payment entry,Pinigais arba banko sąskaitos yra privalomas priimant mokėjimo įrašą
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Studentų Adresas
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Studentų Adresas
DocType: Purchase Invoice,Price List Exchange Rate,Kainų sąrašas Valiutų kursai
apps/erpnext/erpnext/accounts/doctype/account/account.py +251,Account Number {0} already used in account {1},"Sąskaitos numeris {0}, jau naudojamas paskyroje {1}"
DocType: POS Profile,POS Profile Name,POS profilio vardas
DocType: Purchase Invoice Item,Rate,Kaina
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104,Intern,internas
DocType: Delivery Stop,Address Name,adresas pavadinimas
DocType: Stock Entry,From BOM,nuo BOM
DocType: Assessment Code,Assessment Code,vertinimas kodas
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73,Basic,pagrindinis
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Akcijų sandoriai iki {0} yra sušaldyti
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219,Please click on 'Generate Schedule',Prašome spausti &quot;Generuoti grafiką&quot;
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +120,Reference No is mandatory if you entered Reference Date,"Nuorodos Nr yra privaloma, jei įvedėte Atskaitos data"
DocType: Bank Reconciliation Detail,Payment Document,mokėjimo dokumentą
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37,Error evaluating the criteria formula,Klaida įvertinant kriterijų formulę
apps/erpnext/erpnext/hr/doctype/employee/employee.py +115,Date of Joining must be greater than Date of Birth,Stojant data turi būti didesnis nei gimimo data
DocType: Salary Slip,Salary Structure,Pajamos struktūra
DocType: Account,Bank,bankas
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9,Airline,Aviakompanija
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +852,Issue Material,klausimas Medžiaga
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,An error occured while creating recurring,Kuriant pakartotinai įvyko klaida
DocType: Material Request Item,For Warehouse,Sandėliavimo
DocType: Employee,Offer Date,Siūlau data
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,citatos
apps/erpnext/erpnext/accounts/page/pos/pos.js +727,You are in offline mode. You will not be able to reload until you have network.,"Jūs esate neprisijungę. Jūs negalite įkelti, kol turite tinklą."
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,Nėra Studentų grupės sukurta.
DocType: Purchase Invoice Item,Serial No,Serijos Nr
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119,Monthly Repayment Amount cannot be greater than Loan Amount,Mėnesio grąžinimo suma negali būti didesnė nei paskolos suma
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143,Please enter Maintaince Details first,Prašome įvesti maintaince Details pirmas
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Eilutė # {0}: laukiama pristatymo data negali būti prieš Pirkimo užsakymo datą
DocType: Purchase Invoice,Print Language,Spausdinti kalba
DocType: Salary Slip,Total Working Hours,Iš viso darbo valandų
DocType: Subscription,Next Schedule Date,Kitas tvarkaraščio data
DocType: Stock Entry,Including items for sub assemblies,Įskaitant daiktų sub asamblėjose
DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Laikina atidarymo sąskaita
apps/erpnext/erpnext/accounts/page/pos/pos.js +1944,Enter value must be positive,Įveskite vertė turi būti teigiamas
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +392,All Territories,visos teritorijos
DocType: Purchase Invoice,Items,Daiktai
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34,Student is already enrolled.,Studentų jau mokosi.
DocType: Fiscal Year,Year Name,metai Vardas
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +240,There are more holidays than working days this month.,Yra daugiau švenčių nei darbo dienas šį mėnesį.
DocType: Product Bundle Item,Product Bundle Item,Prekės Rinkinys punktas
DocType: Sales Partner,Sales Partner Name,Partneriai pardavimo Vardas
apps/erpnext/erpnext/hooks.py +136,Request for Quotations,Prašymas citatos
DocType: Payment Reconciliation,Maximum Invoice Amount,Maksimalus Sąskaitos faktūros suma
apps/erpnext/erpnext/healthcare/setup.py +210,Haematology,Hematologija
DocType: Normal Test Items,Normal Test Items,Normalūs testo elementai
DocType: Student Language,Student Language,Studentų kalba
apps/erpnext/erpnext/config/selling.py +23,Customers,klientai
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Užsakymas / quot%
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Užsakymas / quot%
apps/erpnext/erpnext/config/healthcare.py +25,Record Patient Vitals,Įrašykite Pacientų Vital
DocType: Fee Schedule,Institution,institucija
DocType: Asset,Partially Depreciated,dalinai nudėvimas
DocType: Issue,Opening Time,atidarymo laikas
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +92,From and To dates required,"Iš ir į datas, reikalingų"
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46,Securities & Commodity Exchanges,Vertybinių popierių ir prekių biržose
apps/erpnext/erpnext/stock/doctype/item/item.py +661,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',"Numatytasis vienetas priemonė variantas &quot;{0}&quot; turi būti toks pat, kaip Šablonas &quot;{1}&quot;"
DocType: Shipping Rule,Calculate Based On,Apskaičiuoti remiantis
DocType: Delivery Note Item,From Warehouse,iš sandėlio
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59,No employees for the mentioned criteria,Nė vienas iš minėtų kriterijų darbuotojų nėra
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +944,No Items with Bill of Materials to Manufacture,"Neturite prekių su Bill iš medžiagų, Gamyba"
DocType: Restaurant,Default Customer,Numatytasis klientas
DocType: Assessment Plan,Supervisor Name,priežiūros Vardas
DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,"Nenurodykite, ar paskyrimas sukurtas tą pačią dieną"
DocType: Program Enrollment Course,Program Enrollment Course,Programos Priėmimas kursai
DocType: Program Enrollment Course,Program Enrollment Course,Programos Priėmimas kursai
DocType: Purchase Taxes and Charges,Valuation and Total,Vertinimas ir viso
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11,Scorecards,Rezultatų kortelės
DocType: Tax Rule,Shipping City,Pristatymas Miestas
DocType: Notification Control,Customize the Notification,Tinkinti Pranešimas
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +19,Cash Flow from Operations,Pinigų srautai iš operacijų
DocType: Purchase Invoice,Shipping Rule,Pristatymas taisyklė
DocType: Patient Relation,Spouse,Sutuoktinis
DocType: Lab Test Groups,Add Test,Pridėti testą
DocType: Manufacturer,Limited to 12 characters,Ribojamas iki 12 simbolių
DocType: Journal Entry,Print Heading,Spausdinti pozicijoje
apps/erpnext/erpnext/config/stock.py +146,Delivery Trip service tours to customers.,Pristatymas Kelionių paslaugų turai klientams.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57,Total cannot be zero,Bendras negali būti nulis
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,&quot;Dienos nuo paskutinė užsakymo&quot; turi būti didesnis nei arba lygus nuliui
DocType: Plant Analysis Criteria,Maximum Permissible Value,Didžiausia leistina vertė
DocType: Journal Entry Account,Employee Advance,Darbuotojo išankstinis mokėjimas
DocType: Payroll Entry,Payroll Frequency,Darbo užmokesčio Dažnio
DocType: Lab Test Template,Sensitivity,Jautrumas
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +62,Raw Material,žaliava
DocType: Leave Application,Follow via Email,Sekite elektroniniu paštu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55,Plants and Machineries,Augalai ir išstumti
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,"Mokesčių suma, nuolaidos suma"
DocType: Daily Work Summary Settings,Daily Work Summary Settings,Dienos darbo santrauka Nustatymai
apps/erpnext/erpnext/controllers/buying_controller.py +457,Please enter Reqd by Date,Prašome įvesti reqd pagal datą
DocType: Payment Entry,Internal Transfer,vidaus perkėlimo
DocType: Asset Maintenance,Maintenance Tasks,Techninės priežiūros užduotys
apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,Bet tikslas Kiekis arba planuojama suma yra privalomi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +367,Please select Posting Date first,Prašome pasirinkti Skelbimo data pirmas
apps/erpnext/erpnext/public/js/account_tree_grid.js +210,Opening Date should be before Closing Date,Atidarymo data turėtų būti prieš uždarant data
DocType: Leave Control Panel,Carry Forward,Tęsti
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cost Center with existing transactions can not be converted to ledger,Kaina centras su esamais sandoriai negali būti konvertuojamos į sąskaitų knygos
DocType: Department,Days for which Holidays are blocked for this department.,"Dienų, kuriomis Šventės blokuojami šiame skyriuje."
DocType: Crop Cycle,Detected Disease,Aptikta liga
,Produced,pagamintas
DocType: Item,Item Code for Suppliers,Prekės kodas tiekėjams
DocType: Issue,Raised By (Email),Iškeltas (el)
DocType: Training Event,Trainer Name,treneris Vardas
DocType: Mode of Payment,General,bendras
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Paskutinis Bendravimas
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Paskutinis Bendravimas
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Negali atskaityti, kai kategorija skirta &quot;Vertinimo&quot; arba &quot;vertinimo ir viso&quot;"
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +234,Serial Nos Required for Serialized Item {0},Eilės Nr Reikalinga už Serijinis punkte {0}
apps/erpnext/erpnext/config/accounts.py +144,Match Payments with Invoices,Rungtynių Mokėjimai sąskaitų faktūrų
DocType: Journal Entry,Bank Entry,bankas įrašas
DocType: Authorization Rule,Applicable To (Designation),Taikoma (paskyrimas)
,Profitability Analysis,pelningumo analizė
DocType: Fees,Student Email,Studento el. Paštas
DocType: Supplier,Prevent POs,Neleisti PO
DocType: Patient,"Allergies, Medical and Surgical History","Alergijos, medicinos ir chirurgijos istorija"
apps/erpnext/erpnext/templates/generators/item.html +62,Add to Cart,Į krepšelį
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Grupuoti pagal
DocType: Guardian,Interests,Pomėgiai
apps/erpnext/erpnext/config/accounts.py +298,Enable / disable currencies.,Įjungti / išjungti valiutas.
DocType: Production Planning Tool,Get Material Request,Gauk Material užklausa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Postal Expenses,pašto išlaidas
apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Iš viso (Amt)
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26,Entertainment & Leisure,Pramogos ir poilsis
,Item Variant Details,Prekės variantai
DocType: Quality Inspection,Item Serial No,Prekė Serijos Nr
apps/erpnext/erpnext/utilities/activation.py +135,Create Employee Records,Sukurti darbuotojų įrašus
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Present,Iš viso dabartis
apps/erpnext/erpnext/config/accounts.py +105,Accounting Statements,apskaitos ataskaitos
DocType: Drug Prescription,Hour,valanda
DocType: Restaurant Order Entry,Last Sales Invoice,Paskutinė pardavimo sąskaita faktūra
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +799,Please select Qty against item {0},Pasirinkite kiekį prieš elementą {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Nauja Serijos Nr negalite turime sandėlyje. Sandėlių turi nustatyti vertybinių popierių atvykimo arba pirkimo kvito
DocType: Lead,Lead Type,Švinas tipas
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133,You are not authorized to approve leaves on Block Dates,Jūs nesate įgaliotas tvirtinti lapus Block Datos
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +383,All these items have already been invoiced,Visi šie elementai jau buvo sąskaitoje
DocType: Company,Monthly Sales Target,Mėnesio pardavimo tikslai
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Gali būti patvirtintas {0}
DocType: Item,Default Material Request Type,Numatytasis Medžiaga Prašymas tipas
DocType: Supplier Scorecard,Evaluation Period,Vertinimo laikotarpis
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13,Unknown,nežinomas
DocType: Shipping Rule,Shipping Rule Conditions,Pristatymas taisyklė sąlygos
DocType: Purchase Invoice,Export Type,Eksporto tipas
DocType: Salary Slip Loan,Salary Slip Loan,Atlyginimo paskolos paskola
DocType: BOM Update Tool,The new BOM after replacement,Naujas BOM po pakeitimo
,Point of Sale,Pardavimo punktas
DocType: Payment Entry,Received Amount,gautos sumos
DocType: Patient,Widow,Našlė
DocType: GST Settings,GSTIN Email Sent On,GSTIN paštas Išsiųsta
DocType: Program Enrollment,Pick/Drop by Guardian,Pasirinkite / Užsukite Guardian
DocType: Production Planning Tool,"Create for full quantity, ignoring quantity already on order","Sukurti visiškai kiekio, ignoruojant kiekį jau tam"
DocType: Crop,Planting UOM,Sodinimas UOM
DocType: Account,Tax,mokestis
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,nežymimi
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1,Opening Invoices Summary,Sąskaitų faktūrų atidarymas santrauka
DocType: Education Settings,Education Manager,Švietimo vadybininkas
DocType: Production Planning Tool,Production Planning Tool,Gamybos planavimo įrankis
DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Mažiausias ilgis tarp kiekvieno augalo lauke optimaliam augimui
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Partijomis {0} Prekė negali būti atnaujintas naudojant Inventorinis susitaikymo, o ne naudoti Inventorinis įrašą"
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Partijomis {0} Prekė negali būti atnaujintas naudojant Inventorinis susitaikymo, o ne naudoti Inventorinis įrašą"
DocType: Quality Inspection,Report Date,Ataskaitos data
DocType: Student,Middle Name,Antras vardas
DocType: C-Form,Invoices,Sąskaitos
DocType: Water Analysis,Type of Sample,Pavyzdžio tipas
DocType: Batch,Source Document Name,Šaltinis Dokumento pavadinimas
DocType: Batch,Source Document Name,Šaltinis Dokumento pavadinimas
DocType: Job Opening,Job Title,Darbo pavadinimas
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84,"{0} indicates that {1} will not provide a quotation, but all items \
					have been quoted. Updating the RFQ quote status.","{0} rodo, kad {1} nepateiks citatos, bet visi daiktai \ &quot;buvo cituoti. RFQ citatos statuso atnaujinimas."
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1004,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Didžiausi mėginiai - {0} jau buvo išsaugoti paketui {1} ir elementui {2} partijoje {3}.
DocType: Manufacturing Settings,Update BOM Cost Automatically,Atnaujinti BOM kainą automatiškai
DocType: Lab Test,Test Name,Testo pavadinimas
apps/erpnext/erpnext/utilities/activation.py +99,Create Users,Sukurti Vartotojai
apps/erpnext/erpnext/utilities/user_progress.py +144,Gram,gramas
DocType: Supplier Scorecard,Per Month,Per mėnesį
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +414,Quantity to Manufacture must be greater than 0.,"Kiekis, Gamyba turi būti didesnis nei 0."
apps/erpnext/erpnext/config/maintenance.py +17,Visit report for maintenance call.,Aplankykite ataskaitą priežiūros skambučio.
DocType: Stock Entry,Update Rate and Availability,Atnaujinti Įvertinti ir prieinamumas
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.,"Procentas jums leidžiama gauti arba pristatyti daugiau prieš užsakyto kiekio. Pavyzdžiui: Jei užsisakėte 100 vienetų. ir jūsų pašalpa yra 10%, tada jums yra leidžiama gauti 110 vienetų."
DocType: POS Customer Group,Customer Group,Klientų grupė
apps/erpnext/erpnext/stock/doctype/batch/batch.js +120,New Batch ID (Optional),Nauja Serija kodas (neprivaloma)
apps/erpnext/erpnext/stock/doctype/batch/batch.js +120,New Batch ID (Optional),Nauja Serija kodas (neprivaloma)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201,Expense account is mandatory for item {0},Kompensuojamos sąskaitos yra privalomas už prekę {0}
DocType: BOM,Website Description,Interneto svetainė Aprašymas
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +42,Net Change in Equity,Grynasis pokytis nuosavo kapitalo
apps/erpnext/erpnext/hub_node/page/hub/hub.js +196,Newest,Naujausias
apps/erpnext/erpnext/assets/doctype/asset/asset.py +167,Please cancel Purchase Invoice {0} first,Prašome anuliuoti sąskaitą-faktūrą {0} pirmas
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"Email Address must be unique, already exists for {0}","Pašto adresas turi būti unikalus, jau egzistuoja {0}"
DocType: Serial No,AMC Expiry Date,AMC Galiojimo data
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +869,Receipt,gavimas
,Sales Register,pardavimų Registruotis
DocType: Daily Work Summary Settings Company,Send Emails At,Siųsti laiškus Šiuo
DocType: Quotation,Quotation Lost Reason,Citata Pamiršote Priežastis
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +368,Transaction reference no {0} dated {1},Operacijos identifikacinis ne {0} data {1}
apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Nėra nieko keisti.
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +483,Form View,Formos peržiūra
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116,Summary for this month and pending activities,Santrauka šį mėnesį ir laukiant veikla
apps/erpnext/erpnext/utilities/user_progress.py +245,"Add users to your organization, other than yourself.","Pridėkite naudotojų prie savo organizacijos, išskyrus save."
DocType: Customer Group,Customer Group Name,Klientų Grupės pavadinimas
apps/erpnext/erpnext/public/js/pos/pos.html +98,No Customers yet!,Nėra Klientai dar!
apps/erpnext/erpnext/public/js/financial_statements.js +56,Cash Flow Statement,Pinigų srautų ataskaita
apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23,Loan Amount cannot exceed Maximum Loan Amount of {0},Paskolos suma negali viršyti maksimalios paskolos sumos iš {0}
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22,License,licencija
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +478,Please remove this Invoice {0} from C-Form {1},Prašome pašalinti šioje sąskaitoje faktūroje {0} iš C formos {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,"Prašome pasirinkti perkelti skirtumą, jei taip pat norite įtraukti praėjusius finansinius metus balanso palieka šią fiskalinių metų"
DocType: GL Entry,Against Voucher Type,Prieš čekių tipas
DocType: Physician,Phone (R),Telefonas (R)
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +50,Time slots added,Laiko laiko intervalai pridedami
DocType: Item,Attributes,atributai
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31,Enable Template,Įgalinti šabloną
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226,Please enter Write Off Account,Prašome įvesti nurašyti paskyrą
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Paskutinė užsakymo data
DocType: Patient,B Negative,B Neigiamas
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25,Maintenance Status has to be Cancelled or Completed to Submit,Techninės priežiūros statusas turi būti atšauktas arba baigtas pateikti
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47,Account {0} does not belongs to company {1},Sąskaita {0} nėra siejamas su kompanijos {1}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +871,Serial Numbers in row {0} does not match with Delivery Note,Serijiniai numeriai {0} eilės nesutampa su Važtaraštis
DocType: Student,Guardian Details,&quot;guardian&quot; informacija
DocType: C-Form,C-Form,C-Forma
apps/erpnext/erpnext/config/hr.py +18,Mark Attendance for multiple employees,Pažymėti Dalyvavimas kelių darbuotojų
DocType: Agriculture Task,Start Day,Pradžios diena
DocType: Vehicle,Chassis No,Važiuoklės Nėra
DocType: Payment Request,Initiated,inicijuotas
DocType: Production Order,Planned Start Date,Planuojama pradžios data
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +596,Please select a BOM,Pasirinkite BOM
DocType: Serial No,Creation Document Type,Kūrimas Dokumento tipas
DocType: Project Task,View Timesheet,Žiūrėti laiko juostą
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54,End date must be greater than start date,Pabaigos data turi būti didesnė už pradžios datą
DocType: Leave Type,Is Encash,Ar inkasuoti
DocType: Leave Allocation,New Leaves Allocated,Naujų lapų Paskirti
apps/erpnext/erpnext/controllers/trends.py +269,Project-wise data is not available for Quotation,Projektų išmintingas duomenys nėra prieinami Citata
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30,End on,Pabaiskite
DocType: Project,Expected End Date,Tikimasi Pabaigos data
DocType: Budget Account,Budget Amount,biudžeto dydis
DocType: Donor,Donor Name,Donoro vardas
DocType: Appraisal Template,Appraisal Template Title,Vertinimas Šablonas Pavadinimas
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39,From Date {0} for Employee {1} cannot be before employee's joining Date {2},Nuo datos {0} Darbuotojo {1} gali būti ne anksčiau darbuotojo jungianti data {2}
apps/erpnext/erpnext/utilities/user_progress_utils.py +29,Commercial,prekybos
DocType: Patient,Alcohol Current Use,Alkoholio vartojimas
DocType: Student Admission Program,Student Admission Program,Studentų priėmimo programa
DocType: Payment Entry,Account Paid To,Sąskaita Paide
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24,Parent Item {0} must not be a Stock Item,Tėvų {0} Prekė turi būti ne riedmenys
apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Visi produktus ar paslaugas.
DocType: Expense Claim,More Details,Daugiau informacijos
DocType: Supplier Quotation,Supplier Address,tiekėjas Adresas
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} biudžetas paskyra {1} prieš {2} {3} yra {4}. Jis bus viršyti {5}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +695,Row {0}# Account must be of type 'Fixed Asset',Eilutės {0} # sąskaita turi būti tipo &quot;ilgalaikio turto&quot;
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,iš Kiekis
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,and unchcked Disabled in the,ir nepakeista. Išjungta
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +46,Series is mandatory,Serija yra privalomi
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28,Financial Services,Finansinės paslaugos
DocType: Student Sibling,Student ID,Studento pažymėjimas
apps/erpnext/erpnext/hub_node/page/hub/hub.js +457,Supplier Email,Tiekėjo el. Pašto adresas
apps/erpnext/erpnext/config/projects.py +46,Types of activities for Time Logs,Veiklos rūšys Time Įrašai
DocType: Opening Invoice Creation Tool,Sales,pardavimų
DocType: Stock Entry Detail,Basic Amount,bazinis dydis
DocType: Training Event,Exam,Egzaminas
DocType: Complaint,Complaint,Skundas
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +449,Warehouse required for stock Item {0},Sandėlių reikalingas akcijų punkte {0}
DocType: Leave Allocation,Unused leaves,nepanaudoti lapai
DocType: Patient,Alcohol Past Use,Alkoholio praeities vartojimas
DocType: Fertilizer Content,Fertilizer Content,Trąšų turinys
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +188,Cr,kr
DocType: Tax Rule,Billing State,atsiskaitymo valstybė
apps/erpnext/erpnext/assets/doctype/asset/asset.js +296,Transfer,perkėlimas
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +916,Fetch exploded BOM (including sub-assemblies),Paduok sprogo BOM (įskaitant mazgus)
DocType: Authorization Rule,Applicable To (Employee),Taikoma (Darbuotojų)
apps/erpnext/erpnext/controllers/accounts_controller.py +136,Due Date is mandatory,Terminas yra privalomi
apps/erpnext/erpnext/controllers/item_variant.py +80,Increment for Attribute {0} cannot be 0,Taškinis atributas {0} negali būti 0
DocType: Journal Entry,Pay To / Recd From,Apmokėti / Recd Nuo
DocType: Naming Series,Setup Series,Sąranka serija
DocType: Payment Reconciliation,To Invoice Date,Norėdami sąskaitos faktūros išrašymo data
DocType: Supplier,Contact HTML,Susisiekite su HTML
DocType: Disease,Treatment Period,Gydymo laikotarpis
apps/erpnext/erpnext/controllers/buying_controller.py +169,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Rezervuota sandėlis yra privalomas prekėms {0} pristatytose žaliavose
,Inactive Customers,neaktyvūs Klientai
DocType: Student Admission Program,Maximum Age,Didžiausias amžius
DocType: Landed Cost Voucher,LCV,lengvųjų komercinių automobilių
DocType: Landed Cost Voucher,Purchase Receipts,pirkimo kvitai
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29,How Pricing Rule is applied?,Kaip kainodaros taisyklė yra taikoma?
DocType: Stock Entry,Delivery Note No,Važtaraštis Nėra
DocType: Production Planning Tool,"If checked, only Purchase material requests for final raw materials will be included in the Material Requests. Otherwise, Material Requests for parent items will be created","Jei pažymėta, tik Pirkimo medžiaga prašymai galutinių žaliavų bus įtrauktas į Materialiųjų prašymus. Priešingu atveju, bus sukurta Medžiaga Prašymai tėvų daiktų"
DocType: Cheque Print Template,Message to show,Žinutė rodoma
apps/erpnext/erpnext/public/js/setup_wizard.js +28,Retail,Mažmeninė
DocType: Student Attendance,Absent,nėra
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591,Product Bundle,Prekės Rinkinys
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,"Neįmanoma rasti rezultato, pradedant {0}. Turite turėti stovinčius balus, apimančius nuo 0 iki 100"
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +206,No submitted Delivery Notes found,Pateiktos pristatymo pastabos nerasta
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +210,Row {0}: Invalid reference {1},Eilutės {0}: Neteisingas nuoroda {1}
DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Pirkimo mokesčius bei rinkliavas šabloną
DocType: Timesheet,TS-,TS-
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Bet debeto ar kredito suma yra reikalingas {2}
DocType: GL Entry,Remarks,Pastabos
DocType: Payment Entry,Account Paid From,Sąskaita mokama iš
DocType: Purchase Order Item Supplied,Raw Material Item Code,Žaliavų punktas kodas
DocType: Task,Parent Task,Tėvų užduotis
DocType: Journal Entry,Write Off Based On,Nurašyti remiantis
apps/erpnext/erpnext/utilities/activation.py +65,Make Lead,Padaryti Švinas
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112,Print and Stationery,Spausdinti Kanceliarinės
DocType: Stock Settings,Show Barcode Field,Rodyti Brūkšninis kodas laukas
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +807,Send Supplier Emails,Siųsti Tiekėjo laiškus
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +115,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Pajamos jau tvarkomi laikotarpį tarp {0} ir {1}, palikite taikymo laikotarpį negali būti tarp šios datos intervalą."
DocType: Chapter Member,Leave Reason,Palikite Priežastis
DocType: Guardian Interest,Guardian Interest,globėjas Palūkanos
DocType: Volunteer,Availability,Prieinamumas
apps/erpnext/erpnext/config/accounts.py +319,Setup default values for POS Invoices,Nustatykite POS sąskaitų faktūrų numatytasis vertes
apps/erpnext/erpnext/config/hr.py +182,Training,mokymas
DocType: Timesheet,Employee Detail,Darbuotojų detalės
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 E-mail ID
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 E-mail ID
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68,Next Date's day and Repeat on Day of Month must be equal,Būsima data diena ir Pakartokite Mėnesio diena turi būti lygi
DocType: Lab Prescription,Test Code,Bandymo kodas
apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Nustatymai svetainės puslapyje
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +38,RFQs are not allowed for {0} due to a scorecard standing of {1},"Paraiškos dėl RFQ dėl {0} neleidžiamos, nes rezultatų rodymas yra {1}"
DocType: Delivery Stop,Select/Unselect Delivery Notes,Pasirinkite / Unselect Pristatymo pastabos
DocType: Offer Letter,Awaiting Response,Laukiama atsakymo
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60,Above,virš
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1399,Total Amount {0},Bendra suma {0}
apps/erpnext/erpnext/controllers/item_variant.py +301,Invalid attribute {0} {1},Neteisingas atributas {0} {1}
DocType: Supplier,Mention if non-standard payable account,"Paminėkite, jei nestandartinis mokama sąskaita"
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +18,Please select the assessment group other than 'All Assessment Groups',Prašome pasirinkti kitą nei &quot;visų vertinimo grupės&quot; įvertinimo grupė
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67,Row {0}: Cost center is required for an item {1},Eilutė {0}: reikalingas elementas {1}
DocType: Training Event Employee,Optional,Neprivaloma
DocType: Salary Slip,Earning & Deduction,Pelningiausi &amp; išskaičiavimas
DocType: Agriculture Analysis Criteria,Water Analysis,Vandens analizė
DocType: Chapter,Region,regionas
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38,Optional. This setting will be used to filter in various transactions.,Neprivaloma. Šis nustatymas bus naudojami filtruoti įvairiais sandoriais.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +110,Negative Valuation Rate is not allowed,Neigiamas vertinimas Balsuok neleidžiama
DocType: Holiday List,Weekly Off,Savaitės Išjungtas
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7,Reload Linked Analysis,Atnaujinti susietą analizę
DocType: Fiscal Year,"For e.g. 2012, 2012-13","Dėl pvz 2012, 2012-13"
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96,Provisional Profit / Loss (Credit),Laikinas Pelnas / nuostolis (kreditas)
DocType: Sales Invoice,Return Against Sales Invoice,Grįžti Against pardavimo sąskaita-faktūra
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32,Item 5,5 punktas
DocType: Serial No,Creation Time,Sukūrimo laikas
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62,Total Revenue,Iš viso pajamų
DocType: Patient,Other Risk Factors,Kiti rizikos veiksniai
DocType: Sales Invoice,Product Bundle Help,Prekės Rinkinys Pagalba
,Monthly Attendance Sheet,Mėnesio Lankomumas lapas
DocType: Production Order Item,Production Order Item,Gamybos Užsakyti punktas
apps/erpnext/erpnext/healthcare/report/lab_test_report/lab_test_report.py +15,No record found,Įrašų rasta
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140,Cost of Scrapped Asset,Išlaidos metalo laužą turto
apps/erpnext/erpnext/controllers/stock_controller.py +236,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Kaina centras yra privalomas punktas {2}
DocType: Vehicle,Policy No,politikos Nėra
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +684,Get Items from Product Bundle,Gauti prekes iš prekė Bundle
DocType: Asset,Straight Line,Tiesi linija
DocType: Project User,Project User,Projektų Vartotojas
apps/erpnext/erpnext/stock/doctype/batch/batch.js +64,Split,skilimas
apps/erpnext/erpnext/stock/doctype/batch/batch.js +64,Split,skilimas
DocType: GL Entry,Is Advance,Ar Išankstinis
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,Lankomumas Iš data ir lankomumo data yra privalomi
apps/erpnext/erpnext/controllers/buying_controller.py +156,Please enter 'Is Subcontracted' as Yes or No,"Prašome įvesti &quot;subrangos sutartis&quot;, nes taip ar ne"
DocType: Item,Default Purchase Unit of Measure,Numatytasis pirkimo vienetas
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Paskutinis Bendravimas data
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Paskutinis Bendravimas data
DocType: Sales Team,Contact No.,Kontaktinė Nr
DocType: Bank Reconciliation,Payment Entries,Apmokėjimo įrašai
DocType: Land Unit,Land Unit Details,Žemės vieneto detalės
DocType: Land Unit,Latitude,Platuma
DocType: Production Order,Scrap Warehouse,laužas sandėlis
DocType: Production Order,Check if material transfer entry is not required,"Patikrinkite, ar medžiaga perdavimo įrašas nereikia"
DocType: Production Order,Check if material transfer entry is not required,"Patikrinkite, ar medžiaga perdavimo įrašas nereikia"
DocType: Program Enrollment Tool,Get Students From,Gauk Studentai iš
apps/erpnext/erpnext/config/learn.py +273,Publish Items on Website,Paskelbti daiktai tinklalapyje
apps/erpnext/erpnext/utilities/activation.py +126,Group your students in batches,Grupė jūsų mokiniai partijomis
DocType: Authorization Rule,Authorization Rule,autorizacija taisyklė
DocType: POS Profile,Offline POS Section,Offline POS skyrius
DocType: Sales Invoice,Terms and Conditions Details,Nuostatos ir sąlygos detalės
apps/erpnext/erpnext/templates/generators/item.html +85,Specifications,specifikacija
DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Pardavimų Mokesčiai ir rinkliavos Šablonų
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68,Total (Credit),Iš viso (kreditų)
DocType: Repayment Schedule,Payment Date,Mokėjimo diena
apps/erpnext/erpnext/stock/doctype/batch/batch.js +114,New Batch Qty,Nauja Serija Kiekis
apps/erpnext/erpnext/stock/doctype/batch/batch.js +114,New Batch Qty,Nauja Serija Kiekis
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10,Apparel & Accessories,Drabužiai ir aksesuarai
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.,"Nepavyko išspręsti svorio rezultatų funkcijos. Įsitikinkite, kad formulė galioja."
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,Taškų ordino
DocType: Item Group,HTML / Banner that will show on the top of product list.,"HTML / reklama, kuri parodys ant produkto sąrašo viršuje."
DocType: Shipping Rule,Specify conditions to calculate shipping amount,Nurodykite sąlygas apskaičiuoti siuntimo sumą
DocType: Program Enrollment,Institute's Bus,Instituto autobusas
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Vaidmuo leidžiama nustatyti užšaldytų sąskaitų ir redaguoti Šaldyti įrašai
DocType: Supplier Scorecard Scoring Variable,Path,Kelias
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28,Cannot convert Cost Center to ledger as it has child nodes,"Negali konvertuoti Cost centrą knygoje, nes ji turi vaikų mazgai"
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +66,Opening Value,atidarymo kaina
DocType: Salary Detail,Formula,formulė
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47,Serial #,Serijinis #
DocType: Lab Test Template,Lab Test Template,Laboratorijos bandymo šablonas
apps/erpnext/erpnext/setup/doctype/company/company.py +170,Sales Account,Pardavimų sąskaita
DocType: Purchase Invoice Item,Total Weight,Bendras svoris
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94,Commission on Sales,Komisija dėl pardavimo
DocType: Offer Letter Term,Value / Description,Vertė / Aprašymas
apps/erpnext/erpnext/controllers/accounts_controller.py +629,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Eilutės # {0}: Turto {1} negali būti pateikti, tai jau {2}"
DocType: Tax Rule,Billing Country,atsiskaitymo Šalis
DocType: Purchase Order Item,Expected Delivery Date,Numatomas pristatymo datos
DocType: Restaurant Order Entry,Restaurant Order Entry,Restorano užsakymo įrašas
apps/erpnext/erpnext/accounts/general_ledger.py +132,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debeto ir kredito nėra vienoda {0} # {1}. Skirtumas yra {2}.
DocType: Asset Maintenance Task,Assign To Name,Priskirti vardui
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98,Entertainment Expenses,Reprezentacinės išlaidos
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +63,Make Material Request,Padaryti Material užklausa
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},Atviras punktas {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Pardavimų sąskaita faktūra {0} turi būti atšauktas iki atšaukti šį pardavimo užsakymų
DocType: Consultation,Age,amžius
DocType: Sales Invoice Timesheet,Billing Amount,atsiskaitymo suma
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,nurodyta už prekę Neteisingas kiekis {0}. Kiekis turėtų būti didesnis nei 0.
DocType: Company,Default Employee Advance Account,Numatytasis darbuotojo išankstinis sąskaita
apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Paraiškos atostogas.
apps/erpnext/erpnext/accounts/doctype/account/account.py +164,Account with existing transaction can not be deleted,Sąskaita su esamais sandoris negali būti išbrauktas
DocType: Vehicle,Last Carbon Check,Paskutinis Anglies Atvykimas
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Legal Expenses,teisinės išlaidos
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140,Please select quantity on row ,Prašome pasirinkti kiekį ant eilėje
apps/erpnext/erpnext/config/accounts.py +277,Make Opening Sales and Purchase Invoices,Atlikti pardavimo ir pirkimo sąskaitas faktūras
DocType: Purchase Invoice,Posting Time,Siunčiamos laikas
DocType: Timesheet,% Amount Billed,% Suma Įvardintas
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +102,"""Time Per Appointment"" hasn""t been set for Dr {0}. Add it in Physician master.",&quot;Laikas per susitikimą&quot; nebuvo nustatytas Dr {0}. Pridėkite jį gydytojo kapitonui.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,Telephone Expenses,telefono išlaidas
DocType: Sales Partner,Logo,logotipas
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.,"Pažymėkite, jei norite priversti vartotoją prieš taupymo pasirinkti seriją. Nebus nutylėjimą, jei jums patikrinti tai."
apps/erpnext/erpnext/stock/get_item_details.py +129,No Item with Serial No {0},Nėra Prekė su Serijos Nr {0}
DocType: Email Digest,Open Notifications,Atviri Pranešimai
DocType: Payment Entry,Difference Amount (Company Currency),Skirtumas Suma (Įmonės valiuta)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79,Direct Expenses,tiesioginės išlaidos
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Naujas klientas pajamos
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119,Travel Expenses,Kelionės išlaidos
DocType: Maintenance Visit,Breakdown,Palaužti
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50,Add custom field Subscription in the doctype {0},Pridėti priskirtą lauko prenumeratą doctype {0}
apps/erpnext/erpnext/controllers/accounts_controller.py +813,Account: {0} with currency: {1} can not be selected,Sąskaita: {0} su valiutos: {1} negalima pasirinkti
DocType: Purchase Receipt Item,Sample Quantity,Mėginio kiekis
DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Atnaujinti BOM išlaidas automatiškai per planuotoją, remiantis naujausiu žaliavų įvertinimo / kainų sąrašo norma / paskutine pirkimo norma."
DocType: Bank Reconciliation Detail,Cheque Date,čekis data
apps/erpnext/erpnext/accounts/doctype/account/account.py +50,Account {0}: Parent account {1} does not belong to company: {2},Sąskaita {0}: Tėvų sąskaitą {1} nepriklauso įmonės: {2}
apps/erpnext/erpnext/setup/doctype/company/company.js +106,Successfully deleted all transactions related to this company!,"Sėkmingai ištrinta visus sandorius, susijusius su šios bendrovės!"
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +21,As on Date,Kaip ir data
DocType: Appraisal,HR,HR
DocType: Program Enrollment,Enrollment Date,Priėmimo data
DocType: Healthcare Settings,Out Patient SMS Alerts,Išeina pacientų SMS perspėjimai
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100,Probation,išbandymas
apps/erpnext/erpnext/config/hr.py +115,Salary Components,Atlyginimo komponentai
DocType: Program Enrollment Tool,New Academic Year,Nauja akademiniai metai
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +809,Return / Credit Note,Prekių grąžinimas / Kredito Pastaba
DocType: Stock Settings,Auto insert Price List rate if missing,"Automatinis įterpti Kainų sąrašas norma, jei trūksta"
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +23,Total Paid Amount,Iš viso sumokėta suma
DocType: Production Order Item,Transferred Qty,perkelta Kiekis
apps/erpnext/erpnext/config/learn.py +11,Navigating,navigacija
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188,Planning,planavimas
DocType: Material Request,Issued,išduotas
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14,Student Activity,Studentų aktyvumas
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80,Supplier Id,tiekėjas ID
DocType: Payment Request,Payment Gateway Details,Mokėjimo šliuzai detalės
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +267,Quantity should be greater than 0,Kiekis turėtų būti didesnis už 0
DocType: Journal Entry,Cash Entry,Pinigai įrašas
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,Child nodes can be only created under 'Group' type nodes,Vaiko mazgai gali būti kuriamos tik pagal &quot;grupė&quot; tipo mazgų
DocType: Leave Application,Half Day Date,Pusė dienos data
DocType: Academic Year,Academic Year Name,Akademiniai metai Vardas
DocType: Sales Partner,Contact Desc,Kontaktinė Aprašymo
apps/erpnext/erpnext/config/hr.py +65,"Type of leaves like casual, sick etc.","Tipas lapų kaip atsitiktinis, serga ir tt"
DocType: Email Digest,Send regular summary reports via Email.,Siųsti reguliarius suvestines ataskaitas elektroniniu paštu.
DocType: Payment Entry,PE-,PE-
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +305,Please set default account in Expense Claim Type {0},Prašome nustatyti numatytąją sąskaitą išlaidų teiginio tipas {0}
DocType: Assessment Result,Student Name,Studento vardas
DocType: Brand,Item Manager,Prekė direktorius
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Payroll Payable,Darbo užmokesčio Mokėtina
DocType: Buying Settings,Default Supplier Type,Numatytasis Tiekėjas tipas
DocType: Plant Analysis,Collection Datetime,Kolekcija Datetime
DocType: Production Order,Total Operating Cost,Iš viso eksploatavimo išlaidos
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171,Note: Item {0} entered multiple times,Pastaba: Prekės {0} įvesta kelis kartus
apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Visi kontaktai.
apps/erpnext/erpnext/public/js/setup_wizard.js +71,Company Abbreviation,Įmonės santrumpa
apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +57,User {0} does not exist,Vartotojas {0} neegzistuoja
DocType: Payment Term,Day(s) after invoice date,Diena (-os) po sąskaitos faktūros datos
DocType: Payment Schedule,Payment Schedule,Mokėjimo planas
DocType: Subscription,SUB-,SUB-
DocType: Item Attribute Value,Abbreviation,santrumpa
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +182,Payment Entry already exists,Mokėjimo įrašas jau yra
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Ne authroized nuo {0} viršija ribas
apps/erpnext/erpnext/config/hr.py +110,Salary template master.,Pajamos šablonas meistras.
apps/erpnext/erpnext/healthcare/setup.py +241,Pathology,Patologija
DocType: Restaurant Order Entry,Restaurant Table,Restorano stalas
DocType: Leave Type,Max Days Leave Allowed,Maksimalus dienų atostogas Leido
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63,Set Tax Rule for shopping cart,Nustatyti Mokesčių taisyklė krepšelį
DocType: Purchase Invoice,Taxes and Charges Added,Mokesčiai ir rinkliavos Pridėta
,Sales Funnel,pardavimų piltuvas
apps/erpnext/erpnext/setup/doctype/company/company.py +48,Abbreviation is mandatory,Santrumpa yra privalomi
DocType: Project,Task Progress,užduotis pažanga
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7,Cart,krepšelis
,Qty to Transfer,Kiekis perkelti
apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,Citatos klientų ar.
DocType: Stock Settings,Role Allowed to edit frozen stock,Vaidmuo leidžiama redaguoti šaldytą žaliavą
,Territory Target Variance Item Group-Wise,Teritorija Tikslinė Dispersija punktas grupė-Išminčius
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,All Customer Groups,Visi klientų grupėms
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114,Accumulated Monthly,sukauptas Mėnesio
apps/erpnext/erpnext/controllers/accounts_controller.py +774,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} yra privalomas. Gal Valiutų įrašas nėra sukurtas {1} ir {2}.
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +41,Tax Template is mandatory.,Mokesčių šablonas yra privalomi.
apps/erpnext/erpnext/accounts/doctype/account/account.py +44,Account {0}: Parent account {1} does not exist,Sąskaita {0}: Tėvų sąskaitą {1} neegzistuoja
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Kainų sąrašas greitis (Įmonės valiuta)
DocType: Products Settings,Products Settings,produktai Nustatymai
,Item Price Stock,Prekės kaina akcijų
DocType: Lab Prescription,Test Created,Testas sukurtas
DocType: Healthcare Settings,Custom Signature in Print,Pasirinktinis parašas spausdinti
DocType: Account,Temporary,laikinas
DocType: Program,Courses,kursai
DocType: Monthly Distribution Percentage,Percentage Allocation,procentas paskirstymas
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128,Secretary,sekretorius
DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction",Jei išjungti &quot;žodžiais&quot; srityje nebus matomas bet koks sandoris
DocType: Serial No,Distinct unit of an Item,Skirtingai vienetas elementą
DocType: Supplier Scorecard Criteria,Criteria Name,Kriterijos pavadinimas
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1289,Please set Company,Prašome nurodyti Company
DocType: Pricing Rule,Buying,pirkimas
apps/erpnext/erpnext/config/agriculture.py +24,Diseases & Fertilizers,Ligos ir trąšos
DocType: HR Settings,Employee Records to be created by,Darbuotojų Įrašai turi būti sukurtas
DocType: Patient,AB Negative,AB Neigiamas
DocType: Sample Collection,SMPL-,SMPL-
DocType: POS Profile,Apply Discount On,Taikyti nuolaidą
DocType: Member,Membership Type,Narystės tipas
,Reqd By Date,Reqd Pagal datą
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140,Creditors,kreditoriai
DocType: Assessment Plan,Assessment Name,vertinimas Vardas
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +96,Row # {0}: Serial No is mandatory,Eilutės # {0}: Serijos Nr privaloma
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Prekė Išminčius Mokesčių detalės
apps/erpnext/erpnext/public/js/setup_wizard.js +71,Institute Abbreviation,institutas santrumpa
,Item-wise Price List Rate,Prekė išmintingas Kainų sąrašas Balsuok
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +970,Supplier Quotation,tiekėjas Citata
DocType: Quotation,In Words will be visible once you save the Quotation.,"Žodžiais bus matomas, kai jūs išgelbėti citatos."
apps/erpnext/erpnext/utilities/transaction_base.py +158,Quantity ({0}) cannot be a fraction in row {1},Kiekis ({0}) negali būti iš eilės frakcija {1}
apps/erpnext/erpnext/utilities/transaction_base.py +158,Quantity ({0}) cannot be a fraction in row {1},Kiekis ({0}) negali būti iš eilės frakcija {1}
DocType: Consultation,C-,C-
DocType: Attendance,ATT-,ATT-
apps/erpnext/erpnext/stock/doctype/item/item.py +473,Barcode {0} already used in Item {1},Brūkšninis kodas {0} jau naudojamas prekės {1}
apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Taisyklės pridedant siuntimo išlaidas.
DocType: Item,Opening Stock,atidarymo sandėlyje
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Klientas turi
DocType: Lab Test,Result Date,Rezultato data
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,{0} yra privalomas Grįžti
DocType: Purchase Order,To Receive,Gauti
apps/erpnext/erpnext/utilities/user_progress.py +249,user@example.com,user@example.com
DocType: Asset,Asset Owner,Turto savininkas
DocType: Employee,Personal Email,Asmeniniai paštas
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57,Total Variance,Iš viso Dispersija
DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Jei įjungta, sistema bus po apskaitos įrašus inventoriaus automatiškai."
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15,Brokerage,tarpininkavimas
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +232,Attendance for employee {0} is already marked for this day,Lankomumas už {0} darbuotojas jau yra pažymėtas šiai dienai
DocType: Production Order Operation,"in Minutes
Updated via 'Time Log'",minutėmis Atnaujinta per &quot;Time Prisijungti&quot;
DocType: Customer,From Lead,nuo švino
apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Užsakymai išleido gamybai.
apps/erpnext/erpnext/public/js/account_tree_grid.js +66,Select Fiscal Year...,Pasirinkite fiskalinių metų ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +554,POS Profile required to make POS Entry,"POS profilis reikalaujama, kad POS įrašą"
DocType: Program Enrollment Tool,Enroll Students,stoti Studentai
DocType: Lab Test,Approved Date,Patvirtinta data
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Standartinė Parduodami
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +148,Atleast one warehouse is mandatory,Atleast vienas sandėlis yra privalomas
DocType: Serial No,Out of Warranty,Iš Garantija
DocType: BOM Update Tool,Replace,pakeisti
apps/erpnext/erpnext/templates/includes/product_list.js +42,No products found.,Nėra prekių nerasta.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +358,{0} against Sales Invoice {1},{0} prieš pardavimo sąskaita-faktūra {1}
DocType: Antibiotic,Laboratory User,Laboratorijos naudotojas
DocType: Sales Invoice,SINV-,SINV-
DocType: Request for Quotation Item,Project Name,projekto pavadinimas
DocType: Customer,Mention if non-standard receivable account,"Nurodyk, jei gautina nestandartinis sąskaita"
DocType: Journal Entry Account,If Income or Expense,Jei pajamos ar sąnaudos
DocType: Production Order,Required Items,Reikalingi daiktai
DocType: Stock Ledger Entry,Stock Value Difference,Akcijų vertės skirtumas
apps/erpnext/erpnext/config/learn.py +234,Human Resource,Žmogiškieji ištekliai
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Mokėjimo Susitaikymas Mokėjimo
DocType: Disease,Treatment Task,Gydymo užduotis
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38,Tax Assets,mokesčio turtas
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +631,Production Order has been {0},Gamybos užsakymas buvo {0}
DocType: BOM Item,BOM No,BOM Nėra
DocType: Instructor,INS/,IP /
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +158,Journal Entry {0} does not have account {1} or already matched against other voucher,Žurnalo įrašą {0} neturi paskyros {1} arba jau suderinta su kitų kuponą
DocType: Item,Moving Average,slenkamasis vidurkis
DocType: BOM Update Tool,The BOM which will be replaced,BOM kuris bus pakeistas
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46,Electronic Equipments,Elektroniniai įrengimai
DocType: Asset,Maintenance Required,Reikalinga techninė priežiūra
DocType: Account,Debit,debetas
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49,Leaves must be allocated in multiples of 0.5,"Lapai turi būti skiriama kartotinus 0,5"
DocType: Production Order,Operation Cost,operacijos išlaidas
apps/erpnext/erpnext/config/hr.py +29,Upload attendance from a .csv file,Įkelti lankomumą iš .csv failą
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45,Outstanding Amt,neįvykdyti Amt
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Nustatyti tikslai punktas grupė-protingas šiam Pardavimų asmeniui.
DocType: Stock Settings,Freeze Stocks Older Than [Days],Freeze Atsargos senesnis nei [diena]
apps/erpnext/erpnext/controllers/accounts_controller.py +599,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Eilutės # {0}: turtas yra privalomas ilgalaikio turto pirkimas / pardavimas
DocType: Asset Maintenance Team,Maintenance Team Name,Techninės priežiūros komandos pavadinimas
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.","Jei du ar daugiau Kainodaros taisyklės yra rasta remiantis pirmiau minėtų sąlygų, pirmenybė taikoma. Prioritetas yra skaičius nuo 0 iki 20, o numatytoji reikšmė yra nulis (tuščias). Didesnis skaičius reiškia, kad jis bus viršesnės jei yra keli kainodaros taisyklės, kurių pačiomis sąlygomis."
apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Fiskalinė Metai: {0} neegzistuoja
DocType: Currency Exchange,To Currency,valiutos
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Leiskite šie vartotojai patvirtinti Leave Paraiškos bendrosios dienų.
apps/erpnext/erpnext/config/hr.py +137,Types of Expense Claim.,Tipai sąskaita reikalavimą.
apps/erpnext/erpnext/controllers/selling_controller.py +147,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Pardavimo normą punkto {0} yra mažesnis nei {1}. Pardavimo kursas turėtų būti atleast {2}
apps/erpnext/erpnext/controllers/selling_controller.py +147,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Pardavimo normą punkto {0} yra mažesnis nei {1}. Pardavimo kursas turėtų būti atleast {2}
DocType: Item,Taxes,Mokesčiai
DocType: Purchase Invoice Item,Weight Per Unit,Svoris vienetui
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344,Paid and Not Delivered,Mokama ir nepareiškė
DocType: Project,Default Cost Center,Numatytasis Kaina centras
DocType: Bank Guarantee,End Date,pabaigos data
apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Akcijų sandoriai
DocType: Budget,Budget Accounts,Biudžetinėse sąskaitose
DocType: Employee,Internal Work History,Vidaus darbo istoriją
DocType: Depreciation Schedule,Accumulated Depreciation Amount,Sukauptas nusidėvėjimas suma
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42,Private Equity,Private Equity &quot;
DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Tiekėjo rezultatų kortelės kintamasis
DocType: Employee Loan,Fully Disbursed,visiškai išmokėta
DocType: Maintenance Visit,Customer Feedback,Klientų Atsiliepimai
DocType: Account,Expense,išlaidos
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +54,Score cannot be greater than Maximum Score,Rezultatas gali būti ne didesnis nei maksimalus įvertinimas
apps/erpnext/erpnext/utilities/user_progress.py +126,Customers and Suppliers,Klientai ir tiekėjai
DocType: Item Attribute,From Range,nuo spektrui
DocType: BOM,Set rate of sub-assembly item based on BOM,Nustatykite komponento surinkimo greitį pagal BOM
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98,Syntax error in formula or condition: {0},Sintaksės klaida formulei ar būklės: {0}
DocType: Daily Work Summary Settings Company,Daily Work Summary Settings Company,Dienos darbo santrauka Nustatymai Įmonės
apps/erpnext/erpnext/stock/utils.py +123,Item {0} ignored since it is not a stock item,"Prekė {0} ignoruojami, nes tai nėra sandėlyje punktas"
DocType: Appraisal,APRSL,APRSL
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +109,Submit this Production Order for further processing.,Pateikti šios produkcijos Rūšiuoti tolesniam perdirbimui.
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.","Norėdami netaikoma kainodaros taisyklė konkrečiu sandoriu, visos taikomos kainodaros taisyklės turi būti išjungta."
DocType: Payment Term,Day(s) after the end of the invoice month,Diena (-os) po sąskaitos faktūros mėnesio pabaigos
DocType: Assessment Group,Parent Assessment Group,Tėvų vertinimas Grupė
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27,Jobs,Darbas
,Sales Order Trends,Pardavimų užsakymų tendencijos
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.,&quot;Iš paketo Nr.&quot; laukas negali būti tuščias ir jo vertė yra mažesnė nei 1.
DocType: Employee,Held On,vyks
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +36,Production Item,Gamybos punktas
,Employee Information,Darbuotojų Informacija
DocType: Stock Entry Detail,Additional Cost,Papildoma Kaina
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +44,"Can not filter based on Voucher No, if grouped by Voucher","Negali filtruoti pagal lakšto, jei grupuojamas kuponą"
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +916,Make Supplier Quotation,Padaryti Tiekėjo Citata
DocType: Quality Inspection,Incoming,įeinantis
apps/erpnext/erpnext/setup/doctype/company/company.js +70,Default tax templates for sales and purchase are created.,Sukuriami numatyti mokesčių šablonai pardavimui ir pirkimui.
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +57,Assessment Result record {0} already exists.,Vertinimo rezultatų įrašas {0} jau egzistuoja.
DocType: BOM,Materials Required (Exploded),"Medžiagų, reikalingų (Išpjovinė)"
apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60,Please set Company filter blank if Group By is 'Company',"Prašome nustatyti Įmonės filtruoti tuščias, jei Grupuoti pagal tai &quot;kompanija&quot;"
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66,Posting Date cannot be future date,Siunčiamos data negali būti ateitis data
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +101,Row # {0}: Serial No {1} does not match with {2} {3},Eilutės # {0}: Serijos Nr {1} nesutampa su {2} {3}
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,for generating the recurring,generuoti pasikartojančius
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86,Casual Leave,Laisvalaikio atostogos
apps/erpnext/erpnext/config/healthcare.py +139,Lab Test UOM.,Lab Test UOM.
DocType: Agriculture Task,End Day,Pabaiga diena
DocType: Batch,Batch ID,Serija ID
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +378,Note: {0},Pastaba: {0}
,Delivery Note Trends,Važtaraštis tendencijos
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112,This Week's Summary,Šios savaitės suvestinė
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22,In Stock Qty,Sandėlyje Kiekis
DocType: Delivery Trip,Calculate Estimated Arrival Times,Apskaičiuokite numatytą atvykimo laiką
apps/erpnext/erpnext/accounts/general_ledger.py +111,Account: {0} can only be updated via Stock Transactions,Sąskaita: {0} gali būti atnaujintas tik per vertybinių popierių sandorių
DocType: Student Group Creation Tool,Get Courses,Gauk kursai
DocType: GL Entry,Party,šalis
DocType: Healthcare Settings,Patient Name,Paciento vardas
DocType: Variant Field,Variant Field,Variantas laukas
DocType: Sales Order,Delivery Date,Pristatymo data
DocType: Opportunity,Opportunity Date,galimybė data
DocType: Purchase Receipt,Return Against Purchase Receipt,Grįžti Prieš pirkimo kvito
DocType: Water Analysis,Person Responsible,Atsakingas asmuo
DocType: Request for Quotation Item,Request for Quotation Item,Užklausimas punktas
DocType: Purchase Order,To Bill,Bill
DocType: Material Request,% Ordered,% Užsakytas
DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.","Kursą, pagrįstą studentų grupės, kurso bus patvirtintas kiekvienas studentas iš užprogramuoto kursai programoje registraciją."
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103,Piecework,vienetinį
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Avg. Buying Rate,Vid. Ieško Balsuok
DocType: Task,Actual Time (in Hours),Tikrasis laikas (valandomis)
DocType: Employee,History In Company,Istorija Company
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +311,New Message from {sender},Nauja žinutė iš {siuntėjo}
apps/erpnext/erpnext/config/learn.py +107,Newsletters,Naujienų prenumerata
DocType: Drug Prescription,Description/Strength,Aprašymas / stiprumas
DocType: Stock Ledger Entry,Stock Ledger Entry,Akcijų Ledgeris įrašas
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83,Same item has been entered multiple times,Tas pats daiktas buvo įvesta kelis kartus
DocType: Department,Leave Block List,Palikite Blokuoti sąrašas
DocType: Purchase Invoice,Tax ID,Mokesčių ID
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192,Item {0} is not setup for Serial Nos. Column must be blank,Prekė {0} nėra setup Serijos Nr. Skiltis turi būti tuščias
DocType: Accounts Settings,Accounts Settings,Sąskaitos Nustatymai
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11,Approve,patvirtinti
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +51,"Malformatted address for {0}, please fix to continue.","Iškabodamas adresas {0}, prašome išspręsti, jei norite tęsti."
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","Naujos sąskaitos numeris, jis bus įtrauktas į sąskaitos pavadinimą kaip prefiksą"
DocType: Maintenance Team Member,Team Member,Komandos narys
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151,No Result to submit,Nėra rezultato pateikti
DocType: Customer,Sales Partner and Commission,Pardavimų partneris ir Komisija
DocType: Employee Loan,Rate of Interest (%) / Year,Palūkanų norma (%) / metus
,Project Quantity,Projektų Kiekis
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'","Viso {0} visoms prekėms yra lygus nuliui, gali būti, jūs turėtumėte pakeisti &quot;Paskirstyti mokesčius pagal&quot;"
DocType: Opportunity,To Discuss,Diskutuoti
apps/erpnext/erpnext/stock/stock_ledger.py +375,{0} units of {1} needed in {2} to complete this transaction.,{0} vienetai {1} reikia {2} užbaigti šį sandorį.
DocType: Loan Type,Rate of Interest (%) Yearly,Palūkanų norma (%) Metinės
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71,Temporary Accounts,Laikinosios sąskaitos
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207,Black,juodas
DocType: BOM Explosion Item,BOM Explosion Item,BOM sprogimo punktas
DocType: Account,Auditor,auditorius
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +132,{0} items produced,{0} daiktai gaminami
apps/erpnext/erpnext/utilities/user_progress.py +55,Learn More,Sužinoti daugiau
DocType: Cheque Print Template,Distance from top edge,Atstumas nuo viršutinio krašto
apps/erpnext/erpnext/stock/get_item_details.py +365,Price List {0} is disabled or does not exist,Kainų sąrašas {0} yra išjungtas arba neegzistuoja
DocType: Purchase Invoice,Return,sugrįžimas
DocType: Production Order Operation,Production Order Operation,Gamybos Užsakyti Operacija
DocType: Pricing Rule,Disable,išjungti
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +186,Mode of payment is required to make a payment,mokėjimo būdas turi atlikti mokėjimą
DocType: Project Task,Pending Review,kol apžvalga
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14,"Edit in full page for more options like assets, serial nos, batches etc.","Visame puslapyje redaguokite daugiau pasirinkčių, pvz., Turto, serijos numerių, siuntų ir pan."
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10,Appointments and Consultations,Paskyrimai ir konsultacijos
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} nėra įtraukti į Serija {2}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113,"Asset {0} cannot be scrapped, as it is already {1}","Turto {0} negali būti sunaikintas, nes jis jau yra {1}"
DocType: Task,Total Expense Claim (via Expense Claim),Bendras išlaidų pretenzija (per expense punktą)
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,Pažymėti Nėra
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40,Failed to setup company,Nepavyko nustatyti įmonės
DocType: Asset Repair,Asset Repair,Turto remontas
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +140,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Eilutės {0}: Valiuta BOM # {1} turi būti lygus pasirinkta valiuta {2}
DocType: Journal Entry Account,Exchange Rate,Valiutos kursas
DocType: Patient,Additional information regarding the patient,Papildoma informacija apie pacientą
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +572,Sales Order {0} is not submitted,Pardavimų užsakymų {0} nebus pateiktas
DocType: Homepage,Tag Line,Gairė linija
DocType: Fee Component,Fee Component,mokestis komponentas
apps/erpnext/erpnext/config/hr.py +204,Fleet Management,laivyno valdymo
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +968,Add items from,Pridėti elementus iš
apps/erpnext/erpnext/config/agriculture.py +7,Crops & Lands,Augalai ir žemės sklypai
DocType: Cheque Print Template,Regular,reguliarus
DocType: Fertilizer,Density (if liquid),Tankis (jei skystis)
apps/erpnext/erpnext/education/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Iš viso weightage visų vertinimo kriterijai turi būti 100%
DocType: Purchase Order Item,Last Purchase Rate,Paskutinis užsakymo kaina
DocType: Account,Asset,Turtas
DocType: Project Task,Task ID,užduoties ID
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84,Stock cannot exist for Item {0} since has variants,Akcijų negali egzistuoti už prekę {0} nes turi variantus
DocType: Lab Test,Mobile,Mobilus
,Sales Person-wise Transaction Summary,Pardavimų Asmuo išmintingas Sandorio santrauka
DocType: Training Event,Contact Number,Kontaktinis telefono numeris
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0} does not exist,Sandėlių {0} neegzistuoja
DocType: Monthly Distribution,Monthly Distribution Percentages,Mėnesio Paskirstymo Procentai
apps/erpnext/erpnext/stock/doctype/batch/batch.py +58,The selected item cannot have Batch,Pasirinktas elementas negali turėti Serija
DocType: Delivery Note,% of materials delivered against this Delivery Note,% Medžiagų pristatytas prieš šią važtaraštyje
DocType: Asset Maintenance Log,Has Certificate,Turi sertifikatą
DocType: Project,Customer Details,klientų informacija
DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,"Patikrinkite, ar turtui reikalinga profilaktinė priežiūra ar kalibravimas"
DocType: Employee,Reports to,Pranešti
,Unpaid Expense Claim,Nemokamos išlaidų Pretenzija
DocType: Payment Entry,Paid Amount,sumokėta suma
apps/erpnext/erpnext/utilities/user_progress.py +155,Explore Sales Cycle,Naršyti pardavimo ciklą
DocType: Assessment Plan,Supervisor,vadovas
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +867,Retention Stock Entry,Saugojimo atsargos įrašas
,Available Stock for Packing Items,Turimas sandėlyje pakuoti prekės
DocType: Item Variant,Item Variant,Prekė variantas
DocType: Assessment Result Tool,Assessment Result Tool,Vertinimo rezultatas įrankis
apps/erpnext/erpnext/education/doctype/instructor/instructor.js +24,As Supervisor,Kaip vadovas
DocType: BOM Scrap Item,BOM Scrap Item,BOM laužas punktas
apps/erpnext/erpnext/accounts/page/pos/pos.js +887,Submitted orders can not be deleted,Pateikė užsakymai negali būti ištrintas
apps/erpnext/erpnext/accounts/doctype/account/account.py +114,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Sąskaitos likutis jau debeto, jums neleidžiama nustatyti &quot;Balansas turi būti&quot; kaip &quot;Kreditas&quot;"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118,Quality Management,kokybės valdymas
apps/erpnext/erpnext/assets/doctype/asset/asset.py +41,Item {0} has been disabled,Prekė {0} buvo išjungta
DocType: Project,Total Billable Amount (via Timesheets),Visa apmokestinamoji suma (per laiko lapus)
DocType: Agriculture Task,Previous Business Day,Ankstesne darbo diena
DocType: Employee Loan,Repay Fixed Amount per Period,Grąžinti fiksuotas dydis vienam laikotarpis
apps/erpnext/erpnext/buying/utils.py +47,Please enter quantity for Item {0},Prašome įvesti kiekį punkte {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +89,Credit Note Amt,Kredito Pastaba Amt
DocType: Employee External Work History,Employee External Work History,Darbuotojų Išorinis Darbo istorija
DocType: Opening Invoice Creation Tool,Purchase,pirkti
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Balansas Kiekis
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,Tikslai negali būti tuščias
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +15,Enrolling students,Įrašyti studentus
DocType: Item Group,Parent Item Group,Tėvų punktas grupė
DocType: Appointment Type,Appointment Type,Paskyrimo tipas
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} už {1}
DocType: Healthcare Settings,Valid number of days,Tinkamas dienų skaičius
apps/erpnext/erpnext/setup/doctype/company/company.js +39,Cost Centers,sąnaudų centrams
DocType: Land Unit,Linked Plant Analysis,Susijusi augalų analizė
DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,"Norma, pagal kurią tiekėjas valiuta yra konvertuojamos į įmonės bazine valiuta"
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Eilutės # {0}: laikus prieštarauja eilės {1}
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Leiskite Zero Vertinimo Balsuok
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Leiskite Zero Vertinimo Balsuok
DocType: Training Event Employee,Invited,kviečiami
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +177,Multiple active Salary Structures found for employee {0} for the given dates,Keli darbuotojo {0} nerasta pagal nurodytą datų aktyvių Atlyginimo struktūros
apps/erpnext/erpnext/config/accounts.py +308,Setup Gateway accounts.,Parametrų Gateway sąskaitos.
DocType: Employee,Employment Type,Užimtumas tipas
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42,Fixed Assets,Ilgalaikis turtas
DocType: Payment Entry,Set Exchange Gain / Loss,Nustatyti keitimo pelnas / nuostolis
,GST Purchase Register,"Paaiškėjo, kad GST Pirkimo Registruotis"
,Cash Flow,Pinigų srautas
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +92,Application period cannot be across two alocation records,Taikymo laikotarpis negali būti per du alocation įrašų
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25,Combined invoice portion must equal 100%,Kombinuota sąskaitos faktūros dalis turi būti lygi 100%
DocType: Item Group,Default Expense Account,Numatytasis išlaidų sąskaita
DocType: GST Account,CGST Account,CGST sąskaita
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,Studentų E-mail ID
DocType: Employee,Notice (days),Pranešimas (dienų)
DocType: Tax Rule,Sales Tax Template,Pardavimo mokestis Šablono
apps/erpnext/erpnext/accounts/page/pos/pos.js +2468,Select items to save the invoice,Pasirinkite elementus išsaugoti sąskaitą faktūrą
DocType: Employee,Encashment Date,išgryninimo data
DocType: Training Event,Internet,internetas
DocType: Special Test Template,Special Test Template,Specialusis bandomasis šablonas
DocType: Account,Stock Adjustment,vertybinių popierių reguliavimas
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34,Default Activity Cost exists for Activity Type - {0},Numatytasis Veiklos sąnaudos egzistuoja veiklos rūšis - {0}
DocType: Production Order,Planned Operating Cost,Planuojamas eksploatavimo išlaidos
DocType: Academic Term,Term Start Date,Kadencijos pradžios data
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,opp Grafas
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,opp Grafas
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +242,Please find attached {0} #{1},Pridedamas {0} # {1}
apps/erpnext/erpnext/controllers/accounts_controller.py +721,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Bendra mokėjimo suma mokėjimo grafike turi būti lygi Grand / Rounded Total
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Banko pažyma likutis vienam General Ledger
DocType: Job Applicant,Applicant Name,Vardas pareiškėjas
DocType: Authorization Rule,Customer / Item Name,Klientas / Prekės pavadinimas
DocType: Buying Settings,"If enabled, last purchase details of items will not be fetched from previous purchase order or purchase receipt","Jei įjungta, paskutiniai elementų pirkimo duomenys nebus surinkti iš ankstesnio pirkimo užsakymo ar pirkimo kvito"
DocType: Product Bundle,"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 

The package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".

For Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.

Note: BOM = Bill of Materials","Kompleksinė grupė ** daiktai ** į kitą ** punkte **. Tai yra naudinga, jei jūs susiejimas tam tikrą ** daiktai ** į pakuotę ir jums išlaikyti atsargas supakuotų ** daiktai **, o ne agregatas ** Elementą **. Paketas ** Prekės ** turės &quot;Ar riedmenys&quot;, kaip &quot;Ne&quot; ir &quot;Ar Pardavimų punktas&quot; kaip &quot;Taip&quot;. Pavyzdžiui: jeigu jūs parduodate Nešiojamieji kompiuteriai ir kuprinės atskirai ir turi ypatingą kainą, jei klientas perka tiek, tada Laptop + kuprinė bus naujas produktas Rinkinys punktas. Pastaba: BOM = Bill of Materials"
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42,Serial No is mandatory for Item {0},Serijos Nr privaloma punkte {0}
DocType: Item Variant Attribute,Attribute,atributas
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43,Please specify from/to range,Prašome nurodyti nuo / iki svyruoja
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28,Opening {0} Invoice created,Atidaryta {0} sukurta sąskaita
DocType: Serial No,Under AMC,pagal AMC
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55,Item valuation rate is recalculated considering landed cost voucher amount,Prekė vertinimas norma perskaičiuojama atsižvelgiant iškrauti išlaidų kvito sumą
apps/erpnext/erpnext/config/selling.py +153,Default settings for selling transactions.,Numatytieji nustatymai pardavimo sandorius.
DocType: Guardian,Guardian Of ,sergėtojos
DocType: Grading Scale Interval,Threshold,Slenkstis
DocType: BOM Update Tool,Current BOM,Dabartinis BOM
apps/erpnext/erpnext/public/js/utils.js +49,Add Serial No,Pridėti Serijos Nr
DocType: Production Order Item,Available Qty at Source Warehouse,Turimas Kiekis prie šaltinio Warehouse
apps/erpnext/erpnext/config/support.py +22,Warranty,garantija
DocType: Purchase Invoice,Debit Note Issued,Debeto Pastaba Išduotas
DocType: Production Order,Warehouses,Sandėliai
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} turtas negali būti perduotas
apps/erpnext/erpnext/stock/doctype/item/item.js +80,This Item is a Variant of {0} (Template).,Šis elementas yra {0} (šablonų) variantas.
DocType: Workstation,per hour,per valandą
apps/erpnext/erpnext/config/buying.py +7,Purchasing,Pirkimas
DocType: Announcement,Announcement,skelbimas
DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","UŽ SERIJŲ remiantis studentų grupę, studentas Serija bus patvirtintas kiekvienas studentas iš programos registraciją."
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +51,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Sandėlių negali būti išbrauktas, nes egzistuoja akcijų knygos įrašas šiame sandėlyje."
apps/erpnext/erpnext/public/js/setup_wizard.js +25,Distribution,pasiskirstymas
DocType: Expense Claim Advance,Expense Claim Advance,Išankstinio išlaidų reikalavimas
DocType: Lab Test,Report Preference,Pranešimo nuostatos
apps/erpnext/erpnext/config/non_profit.py +43,Volunteer information.,Savanorio informacija.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133,Project Manager,Projekto vadovas
,Quoted Item Comparison,Cituojamas punktas Palyginimas
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34,Overlap in scoring between {0} and {1},Pervykimas taškų tarp {0} ir {1}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114,Dispatch,išsiuntimas
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +73,Max discount allowed for item: {0} is {1}%,Maksimali nuolaida leidžiama punktu: {0} yra {1}%
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176,Net Asset value as on,"Grynoji turto vertė, nuo"
DocType: Crop,Produce,Gaminti
DocType: Account,Receivable,gautinos
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Eilutės # {0}: Neleidžiama keisti tiekėjo Užsakymo jau egzistuoja
DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,"Vaidmenį, kurį leidžiama pateikti sandorius, kurie viršija nustatytus kredito limitus."
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +978,Select Items to Manufacture,Pasirinkite prekę Gamyba
DocType: Delivery Stop,Delivery Stop,Pristatymas Stotelė
apps/erpnext/erpnext/accounts/page/pos/pos.js +955,"Master data syncing, it might take some time","Master Data sinchronizavimą, tai gali užtrukti šiek tiek laiko"
DocType: Item,Material Issue,medžiaga išdavimas
DocType: Employee Education,Qualification,kvalifikacija
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +40,View Salary Slips,Peržiūrėti atlyginimus
DocType: Item Price,Item Price,Prekė Kaina
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48,Soap & Detergent,"Muilas, skalbimo"
DocType: BOM,Show Items,Rodyti prekių
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,Nuo laikas negali būti didesnis nei laiko.
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +74,Do you want to notify all the customers by email?,Ar norite pranešti visiems klientams elektroniniu paštu?
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36,Motion Picture & Video,Filmavimo ir vaizdo
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Užsakytas
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51,Resume,Tęsti
DocType: Salary Detail,Component,Komponentas
DocType: Assessment Criteria,Assessment Criteria Group,Vertinimo kriterijai grupė
DocType: Healthcare Settings,Patient Name By,Paciento vardas
apps/erpnext/erpnext/assets/doctype/asset/asset.py +72,Opening Accumulated Depreciation must be less than equal to {0},Atidarymo Sukauptas nusidėvėjimas turi būti mažesnis arba lygus {0}
DocType: Warehouse,Warehouse Name,Sandėlių Vardas
DocType: Naming Series,Select Transaction,Pasirinkite Sandorio
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,Prašome įvesti patvirtinimo vaidmuo arba patvirtinimo vartotoją
DocType: Journal Entry,Write Off Entry,Nurašyti įrašą
DocType: BOM,Rate Of Materials Based On,Norma medžiagų pagrindu
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,paramos Analtyics
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102,Uncheck all,Nuimkite visus
DocType: POS Profile,Terms and Conditions,Terminai ir sąlygos
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49,To Date should be within the Fiscal Year. Assuming To Date = {0},"Data turi būti per finansinius metus. Darant prielaidą, kad Norėdami data = {0}"
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Čia galite išsaugoti ūgį, svorį, alergijos, medicinos problemas ir tt"
DocType: Leave Block List,Applies to Company,Taikoma Company
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +222,Cannot cancel because submitted Stock Entry {0} exists,"Negali atšaukti, nes pateiktas sandėlyje Įėjimo {0} egzistuoja"
DocType: Employee Loan,Disbursement Date,išmokėjimas data
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80,'Recipients' not specified,&quot;Gavėjai&quot; nenurodyta
DocType: BOM Update Tool,Update latest price in all BOMs,Atnaujinkite naujausią kainą visose BOM
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +39,Medical Record,Medicininis įrašas
DocType: Vehicle,Vehicle,transporto priemonė
DocType: Purchase Invoice,In Words,Žodžiais
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15,{0} must be submitted,{0} turi būti pateiktas
DocType: POS Profile,Item Groups,Prekė Grupės
apps/erpnext/erpnext/hr/doctype/employee/employee.py +221,Today is {0}'s birthday!,Šiandien {0} gimtadienis!
DocType: Production Planning Tool,Material Request For Warehouse,Medžiaga Prašymas Warehouse
DocType: Sales Order Item,For Production,gamybai
DocType: Payment Request,payment_url,payment_url
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +163,Please add a Temporary Opening account in Chart of Accounts,Pridėkite laikinąją atidarymo sąskaitą sąskaitų grafike
DocType: Customer,Customer Primary Contact,Pirmasis kliento kontaktas
DocType: Project Task,View Task,Peržiūrėti Užduotis
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Opp / Švinas%
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Opp / Švinas%
DocType: Material Request,MREQ-,MREQ-
DocType: Payment Schedule,Invoice Portion,Sąskaita faktūra porcija
,Asset Depreciations and Balances,Turto Nusidėvėjimas ir likučiai
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +357,Amount {0} {1} transferred from {2} to {3},Suma {0} {1} perkeliamas iš {2} į {3}
DocType: Sales Invoice,Get Advances Received,Gauti gautų išankstinių
DocType: Email Digest,Add/Remove Recipients,Įdėti / pašalinti gavėjus
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +491,Transaction not allowed against stopped Production Order {0},Sandorio neleidžiama prieš nutraukė gamybą Užsakyti {0}
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","Norėdami nustatyti šią fiskalinių metų kaip numatytąjį, spustelėkite ant &quot;Set as Default&quot;"
apps/erpnext/erpnext/projects/doctype/project/project.py +216,Join,prisijungti
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21,Shortage Qty,trūkumo Kiekis
apps/erpnext/erpnext/stock/doctype/item/item.py +645,Cannot change Variant properties after stock transction. You will have to make a new Item to do this.,"Negalima pakeisti variantų savybių po atsargų perkėlimo. Norėdami tai padaryti, turėsite padaryti naują punktą."
apps/erpnext/erpnext/stock/doctype/item/item.py +685,Item variant {0} exists with same attributes,Prekė variantas {0} egzistuoja pačių savybių
DocType: Employee Loan,Repay from Salary,Grąžinti iš Pajamos
DocType: Leave Application,LAP/,juosmens /
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +347,Requesting payment against {0} {1} for amount {2},"Prašančioji mokėjimą nuo {0} {1} už sumą, {2}"
DocType: Salary Slip,Salary Slip,Pajamos Kuponas
DocType: Lead,Lost Quotation,Pamiršote Citata
apps/erpnext/erpnext/utilities/user_progress.py +218,Student Batches,Studentų partijos
DocType: Pricing Rule,Margin Rate or Amount,Marža norma arba suma
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48,'To Date' is required,&quot;Norėdami data&quot; reikalingas
DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Sukurti pakavimo lapelius paketai turi būti pareikšta. Naudota pranešti pakuotės numeris, pakuočių turinį ir jo svorį."
DocType: Sales Invoice Item,Sales Order Item,Pardavimų užsakymų punktas
DocType: Salary Slip,Payment Days,Atsiskaitymo diena
DocType: Stock Settings,Convert Item Description to Clean HTML,"Konvertuoti elemento apibūdinimą, norint išvalyti HTML"
DocType: Patient,Dormant,neveikiantis
DocType: Salary Slip,Total Interest Amount,Bendra palūkanų suma
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +125,Warehouses with child nodes cannot be converted to ledger,Sandėliai su vaikų mazgų negali būti konvertuojamos į sąskaitų knygos
DocType: BOM,Manage cost of operations,Tvarkyti išlaidas operacijoms
DocType: Accounts Settings,Stale Days,Pasenusios dienos
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.","Kai bet kuri iš patikrintų sandorių &quot;Pateikė&quot;, elektroninio pašto Iššokantis automatiškai atidaryti siųsti el.laišką susijusios &quot;Kontaktai&quot; toje sandorio su sandoriu kaip priedą. Vartotojas gali arba negali siųsti laišką."
apps/erpnext/erpnext/config/setup.py +14,Global Settings,Bendrosios nuostatos
DocType: Crop,Row Spacing UOM,Eilučių tarpas UOM
DocType: Assessment Result Detail,Assessment Result Detail,Vertinimo rezultatas detalės
DocType: Employee Education,Employee Education,Darbuotojų Švietimas
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53,Duplicate item group found in the item group table,Dubliuoti punktas grupė rastas daiktas grupės lentelėje
DocType: Land Unit,Parent Land Unit,Tėvų žemės skyrius
apps/erpnext/erpnext/public/js/controllers/transaction.js +1101,It is needed to fetch Item Details.,"Jis reikalingas, kad parsiųsti Išsamesnė informacija."
DocType: Fertilizer,Fertilizer Name,Trąšų pavadinimas
DocType: Salary Slip,Net Pay,Grynasis darbo užmokestis
DocType: Account,Account,sąskaita
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217,Serial No {0} has already been received,Serijos Nr {0} jau gavo
,Requested Items To Be Transferred,Pageidaujami daiktai turi būti perkeltos
DocType: Expense Claim,Vehicle Log,Automobilio Prisijungti
DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Karščiavimas (temperatūra&gt; 38,5 ° C / 101,3 ° F arba išlaikoma temperatūra&gt; 38 ° C / 100,4 ° F)"
DocType: Customer,Sales Team Details,Sales Team detalės
apps/erpnext/erpnext/accounts/page/pos/pos.js +1342,Delete permanently?,Ištrinti visam laikui?
DocType: Expense Claim,Total Claimed Amount,Iš viso ieškinių suma
apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Galimas galimybės pardavinėti.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +228,Invalid {0},Neteisingas {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90,Sick Leave,atostogos dėl ligos
DocType: Email Digest,Email Digest,paštas Digest &quot;
DocType: Delivery Note,Billing Address Name,Atsiskaitymo Adresas Pavadinimas
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22,Department Stores,Universalinės parduotuvės
,Item Delivery Date,Prekės pristatymo data
DocType: Warehouse,PIN,PIN kodas
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +125,Error '{0}' occured. Arguments {1}.,Klaida &quot;{0}&quot; įvyko. Argumentai {1}.
DocType: Bin,Reserved Qty for sub contract,Rezervuota Kiekis pagal subrangos sutartį
DocType: Sales Invoice,Base Change Amount (Company Currency),Bazinė Pakeisti Suma (Įmonės valiuta)
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304,No accounting entries for the following warehouses,Nieko apskaitos įrašai šiuos sandėlius
apps/erpnext/erpnext/projects/doctype/project/project.js +111,Save the document first.,Išsaugoti dokumentą pirmas.
apps/erpnext/erpnext/shopping_cart/cart.py +71,Only {0} in stock for item {1},Tik {0} prekės vienetui {1}
DocType: Account,Chargeable,Apmokestinimo
DocType: Company,Change Abbreviation,Pakeisti santrumpa
DocType: Expense Claim Detail,Expense Date,Kompensuojamos data
DocType: Item,Max Discount (%),Maksimali nuolaida (%)
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30,Credit Days cannot be a negative number,Kreditų dienos negali būti neigiamas skaičius
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Paskutinė užsakymo suma
apps/erpnext/erpnext/stock/doctype/item/item.py +264," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Išsaugoti pavyzdį yra pagrįstas partija, prašome patikrinti, ar turi partijos Nr, kad būtų išsaugotas prekės pavyzdys"
DocType: Task,Is Milestone,Ar Milestone
DocType: Delivery Stop,Email Sent To,Paštas siunčiami
DocType: Budget,Warn,įspėti
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81,Are you sure you want to unregister?,Ar tikrai norite atsisakyti registracijos?
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Bet koks kitas pastabas, pažymėtina pastangų, kad reikia eiti į apskaitą."
DocType: Asset Maintenance,Manufacturing User,gamyba Vartotojas
DocType: Purchase Invoice,Raw Materials Supplied,Žaliavos Pateikiamas
DocType: C-Form,Series,serija
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +273,Currency of the price list {0} must be {1} or {2},Kainų sąrašo {0} valiuta turi būti {1} arba {2}
DocType: Appraisal,Appraisal Template,vertinimas Šablono
DocType: Soil Texture,Ternary Plot,Ternary Plot
DocType: Item Group,Item Classification,Prekė klasifikavimas
DocType: Driver,License Number,Licencijos numeris
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131,Business Development Manager,Verslo plėtros vadybininkas
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Priežiūra vizito tikslas
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19,Invoice Patient Registration,Sąskaitos pacientų registracija
DocType: Crop,Period,laikotarpis
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +18,General Ledger,Bendra Ledgeris
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33,Employee {0} on Leave on {1},Darbuotojų {0} atostogose dėl {1}
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Peržiūrėti laidai
DocType: Program Enrollment Tool,New Program,nauja programa
DocType: Item Attribute Value,Attribute Value,Pavadinimas Reikšmė
,Itemwise Recommended Reorder Level,Itemwise Rekomenduojama Pertvarkyti lygis
DocType: Salary Detail,Salary Detail,Pajamos detalės
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1043,Please select {0} first,Prašome pasirinkti {0} pirmas
DocType: Appointment Type,Physician,Gydytojas
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +850,Batch {0} of Item {1} has expired.,Serija {0} punkto {1} yra pasibaigęs.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,Konsultacijos
DocType: Sales Invoice,Commission,Komisija
apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Laikas lapas gamybai.
apps/erpnext/erpnext/templates/pages/cart.html +37,Subtotal,Tarpinė suma
DocType: Physician,Charges,Mokesčiai
DocType: Salary Detail,Default Amount,numatytasis dydis
DocType: Lab Test Template,Descriptive,Apibūdinamasis
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +95,Warehouse not found in the system,Sandėlių nerastas sistemos
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115,This Month's Summary,Šio mėnesio suvestinė
DocType: Quality Inspection Reading,Quality Inspection Reading,Kokybės inspekcija skaitymas
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25,`Freeze Stocks Older Than` should be smaller than %d days.,&quot;Freeze Atsargos Senesni Than` turėtų būti mažesnis nei% d dienų.
DocType: Tax Rule,Purchase Tax Template,Pirkimo Mokesčių šabloną
apps/erpnext/erpnext/utilities/user_progress.py +45,Set a sales goal you'd like to achieve for your company.,"Nustatykite pardavimo tikslą, kurį norite pasiekti savo bendrovei."
,Project wise Stock Tracking,Projektų protinga sandėlyje sekimo
DocType: GST HSN Code,Regional,regioninis
apps/erpnext/erpnext/config/healthcare.py +40,Laboratory,Laboratorija
DocType: Stock Entry Detail,Actual Qty (at source/target),Tikrasis Kiekis (bent šaltinio / target)
DocType: Item Customer Detail,Ref Code,teisėjas kodas
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75,Customer Group is Required in POS Profile,Klientų grupė reikalinga POS profilį
apps/erpnext/erpnext/config/hr.py +12,Employee records.,Darbuotojų įrašus.
apps/erpnext/erpnext/assets/doctype/asset/asset.py +95,Please set Next Depreciation Date,Prašome nustatyti Kita nusidėvėjimo data
DocType: HR Settings,Payroll Settings,Payroll Nustatymai
apps/erpnext/erpnext/config/accounts.py +146,Match non-linked Invoices and Payments.,Rungtynių nesusieti sąskaitų faktūrų ir mokėjimų.
DocType: POS Settings,POS Settings,POS nustatymai
apps/erpnext/erpnext/templates/pages/cart.html +16,Place Order,Vieta Užsakyti
DocType: Email Digest,New Purchase Orders,Nauja Užsakymų
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,Root cannot have a parent cost center,Šaknų negali turėti tėvų ekonominį centrą
apps/erpnext/erpnext/public/js/stock_analytics.js +57,Select Brand...,Pasirinkite prekės ...
apps/erpnext/erpnext/public/js/setup_wizard.js +32,Non Profit (beta),Ne pelno (beta)
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18,Training Events/Results,Mokymo Renginiai / Rezultatai
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152,Accumulated Depreciation as on,Sukauptas nusidėvėjimas nuo
DocType: Sales Invoice,C-Form Applicable,"C-formos, taikomos"
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +419,Operation Time must be greater than 0 for Operation {0},Operacijos metu turi būti didesnis nei 0 darbui {0}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +106,Warehouse is mandatory,Sandėlių yra privalomi
DocType: Supplier,Address and Contacts,Adresas ir kontaktai
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67,Failed to create website,Nepavyko sukurti svetainės
DocType: Soil Analysis,Mg/K,Mg / K
DocType: UOM Conversion Detail,UOM Conversion Detail,UOM konversijos detalės
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +922,Retention Stock Entry already created or Sample Quantity not provided,Sulaikymo atsargų įrašas jau sukurtas arba nepateiktas mėginio kiekis
DocType: Program,Program Abbreviation,programos santrumpa
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +407,Production Order cannot be raised against a Item Template,Gamybos nurodymas negali būti iškeltas prieš Prekės Šablonas
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52,Charges are updated in Purchase Receipt against each item,Mokesčiai yra atnaujinama pirkimo kvitą su kiekvieno elemento
DocType: Warranty Claim,Resolved By,sprendžiami
DocType: Bank Guarantee,Start Date,Pradžios data
apps/erpnext/erpnext/config/hr.py +75,Allocate leaves for a period.,Skirti lapai laikotarpiui.
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Čekiai ir užstatai neteisingai išvalytas
apps/erpnext/erpnext/accounts/doctype/account/account.py +46,Account {0}: You can not assign itself as parent account,Sąskaita {0}: Jūs negalite priskirti save kaip patronuojančios sąskaitą
DocType: Purchase Invoice Item,Price List Rate,Kainų sąrašas Balsuok
apps/erpnext/erpnext/utilities/activation.py +72,Create customer quotes,Sukurti klientų citatos
DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Rodyti &quot;Sandėlyje&quot; arba &quot;nėra sandėlyje&quot; remiantis sandėlyje turimus šiame sandėlį.
apps/erpnext/erpnext/config/manufacturing.py +38,Bill of Materials (BOM),Bilis medžiagos (BOM)
DocType: Item,Average time taken by the supplier to deliver,"Vidutinis laikas, per kurį tiekėjas pateikia"
DocType: Sample Collection,Collected By,Surinkta
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +35,Assessment Result,vertinimo rezultatas
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,valandos
DocType: Project,Expected Start Date,"Tikimasi, pradžios data"
apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant Details Report,Variantas išsamios ataskaitos
DocType: Setup Progress Action,Setup Progress Action,&quot;Progress&quot; veiksmo nustatymas
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +36,Buying Price List,Pirkimo kainoraštis
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49,Remove item if charges is not applicable to that item,Pašalinti elementą jei mokesčiai nėra taikomi šio elemento
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21,Please select Maintenance Status as Completed or remove Completion Date,Pasirinkite techninės priežiūros būseną kaip užbaigtą arba pašalinkite užbaigimo datą
DocType: Supplier,Default Payment Terms Template,Numatytasis mokėjimo sąlygų šablonas
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34,Transaction currency must be same as Payment Gateway currency,"Operacijos valiuta turi būti toks pat, kaip mokėjimo šliuzai valiuta"
DocType: Payment Entry,Receive,gauti
apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,citatos:
DocType: Maintenance Visit,Fully Completed,visiškai užbaigtas
apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}% Visiškas
DocType: Employee,Educational Qualification,edukacinė kvalifikacija
DocType: Workstation,Operating Costs,Veiklos sąnaudos
DocType: Budget,Action if Accumulated Monthly Budget Exceeded,"Veiksmų, jei sukauptos mėnesio biudžetas Viršytas"
DocType: Subscription,Submit on creation,Pateikti steigti
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +470,Currency for {0} must be {1},Valiuta {0} turi būti {1}
DocType: Asset,Disposal Date,Atliekų data
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.","Laiškai bus siunčiami į visus aktyvius bendrovės darbuotojams už tam tikrą valandą, jei jie neturi atostogų. Atsakymų santrauka bus išsiųstas vidurnaktį."
DocType: Employee Leave Approver,Employee Leave Approver,Darbuotojų atostogos Tvirtintojas
apps/erpnext/erpnext/stock/doctype/item/item.py +485,Row {0}: An Reorder entry already exists for this warehouse {1},Eilutės {0}: an Pertvarkyti įrašas jau yra šiam sandėlį {1}
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99,"Cannot declare as lost, because Quotation has been made.","Negali paskelbti, kad prarastas, nes Citata buvo padaryta."
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16,Training Feedback,Mokymai Atsiliepimai
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +488,Production Order {0} must be submitted,Gamybos Užsakyti {0} turi būti pateiktas
DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Tiekėjo rezultatų vertinimo kriterijai
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149,Please select Start Date and End Date for Item {0},Prašome pasirinkti pradžios ir pabaigos data punkte {0}
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},"Žinoma, yra privalomi eilės {0}"
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,Iki šiol gali būti ne anksčiau iš dienos
DocType: Supplier Quotation Item,Prevdoc DocType,Prevdoc dokumentų tipas
apps/erpnext/erpnext/stock/doctype/item/item.js +268,Add / Edit Prices,Įdėti / Redaguoti kainas
DocType: Batch,Parent Batch,tėvų Serija
DocType: Batch,Parent Batch,tėvų Serija
DocType: Cheque Print Template,Cheque Print Template,Čekis Spausdinti Šablono
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36,Chart of Cost Centers,Schema sąnaudų centrams
DocType: Lab Test Template,Sample Collection,Pavyzdžių rinkinys
,Requested Items To Be Ordered,Pageidaujami Daiktai nurodoma padengti
apps/erpnext/erpnext/hub_node/page/hub/hub.js +655,My Orders,Mano įsakymai
DocType: Price List,Price List Name,Kainų sąrašas vardas
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +32,Daily Work Summary for {0},Kasdieniniame darbe santrauka {0}
DocType: BOM,Manufacturing,gamyba
,Ordered Items To Be Delivered,Užsakytas prekes turi būti pateikta
DocType: Account,Income,Pajamos
DocType: Industry Type,Industry Type,pramonė tipas
apps/erpnext/erpnext/templates/includes/cart.js +150,Something went wrong!,Kažkas atsitiko!
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +124,Warning: Leave application contains following block dates,Įspėjimas: Palikite paraiškoje yra šie blokas datos
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +266,Sales Invoice {0} has already been submitted,Pardavimų sąskaita faktūra {0} jau buvo pateikta
DocType: Supplier Scorecard Scoring Criteria,Score,rezultatas
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Finansiniai metai {0} neegzistuoja
DocType: Asset Maintenance Log,Completion Date,užbaigimo data
DocType: Purchase Invoice Item,Amount (Company Currency),Suma (Įmonės valiuta)
DocType: Agriculture Analysis Criteria,Agriculture User,Žemės ūkio naudotojas
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38,Valid till date cannot be before transaction date,Galioja iki datos negali būti prieš sandorio datą
apps/erpnext/erpnext/stock/stock_ledger.py +379,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} vienetai {1} reikia {2} į {3} {4} ir {5} užbaigti šį sandorį.
DocType: Fee Schedule,Student Category,Studentų Kategorija
DocType: Announcement,Student,Studentas
apps/erpnext/erpnext/config/hr.py +238,Organization unit (department) master.,Organizavimo skyrius (departamentas) meistras.
DocType: Shipping Rule,Shipping Rule Type,Pristatymo taisyklės tipas
apps/erpnext/erpnext/utilities/user_progress.py +236,Go to Rooms,Eikite į kambarius
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,Prašome įvesti žinutę prieš išsiunčiant
DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUBLIKATAS tiekėjas
DocType: Email Digest,Pending Quotations,kol Citatos
apps/erpnext/erpnext/config/accounts.py +318,Point-of-Sale Profile,Point-of-Sale profilis
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156,Unsecured Loans,neužtikrintas paskolas
DocType: Cost Center,Cost Center Name,Kainuos centras vardas
DocType: Student,B+,B +
DocType: HR Settings,Max working hours against Timesheet,Maksimalus darbo laikas nuo laiko apskaitos žiniaraštis
DocType: Maintenance Schedule Detail,Scheduled Date,Numatoma data
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +88,Total Paid Amt,Visų mokamų Amt
DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Žinutės didesnis nei 160 simboliai bus padalintas į keletą pranešimų
DocType: Purchase Receipt Item,Received and Accepted,Gavo ir patvirtino
DocType: Hub Settings,Company and Seller Profile,Įmonės ir pardavėjo profilis
,GST Itemised Sales Register,"Paaiškėjo, kad GST Detalios Pardavimų Registruotis"
DocType: Soil Texture,Silt Loam,Silt Loam
,Serial No Service Contract Expiry,Serijos Nr Paslaugų sutarties galiojimo pabaigos
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +297,You cannot credit and debit same account at the same time,Jūs negalite Kredito ir debeto pačią sąskaitą tuo pačiu metu
DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Suaugusiųjų pulso dažnis yra nuo 50 iki 80 smūgių per minutę.
DocType: Naming Series,Help HTML,Pagalba HTML
DocType: Student Group Creation Tool,Student Group Creation Tool,Studentų grupė kūrimo įrankis
DocType: Item,Variant Based On,Variantas remiantis
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53,Total weightage assigned should be 100%. It is {0},Iš viso weightage priskirti turi būti 100%. Ji yra {0}
apps/erpnext/erpnext/utilities/user_progress.py +106,Your Suppliers,Jūsų tiekėjai
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,Please correct the,Prašome ištaisyti
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80,Cannot set as Lost as Sales Order is made.,Negalima nustatyti kaip Pamiršote nes yra pagamintas pardavimų užsakymų.
DocType: Request for Quotation Item,Supplier Part No,Tiekėjas partijos nr
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',"Negali atskaityti, kai kategorija skirta &quot;Vertinimo&quot; arba &quot;Vaulation ir viso&quot;"
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364,Received From,Gautas nuo
DocType: Lead,Converted,Perskaičiuotas
DocType: Item,Has Serial No,Turi Serijos Nr
DocType: Employee,Date of Issue,Išleidimo data
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +24,{0}: From {0} for {1},{0}: Nuo {0} už {1}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}","Kaip už pirkimo parametrus, jei pirkimas Čekio Reikalinga == &quot;Taip&quot;, tada sukurti sąskaitą-faktūrą, vartotojo pirmiausia reikia sukurti pirkimo kvitą už prekę {0}"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167,Row #{0}: Set Supplier for item {1},Eilutės # {0}: Nustatykite Tiekėjas už prekę {1}
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,Row {0}: Hours value must be greater than zero.,Eilutės {0}: valandos vertė turi būti didesnė už nulį.
apps/erpnext/erpnext/stock/doctype/item/item.py +185,Website Image {0} attached to Item {1} cannot be found,Interneto svetainė Paveikslėlis {0} pridedamas prie punkto {1} negali būti rastas
DocType: Issue,Content Type,turinio tipas
DocType: Asset,Assets,Turtas
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17,Computer,Kompiuteris
DocType: Item,List this Item in multiple groups on the website.,Sąrašas šį Elementą keliomis grupėmis svetainėje.
DocType: Payment Term,Due Date Based On,Terminas pagrįstas
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +85,Please set default customer group and territory in Selling Settings,Nustatykite numatytuosius klientų grupės ir teritorijos nustatymus
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +203,{0} {1} does not exist,{0} {1} neegzistuoja
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +321,Please check Multi Currency option to allow accounts with other currency,Prašome patikrinti Multi Valiuta galimybę leisti sąskaitas kita valiuta
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +85,Item: {0} does not exist in the system,Punktas: {0} neegzistuoja sistemoje
apps/erpnext/erpnext/accounts/doctype/account/account.py +106,You are not authorized to set Frozen value,Jūs nesate įgaliotas nustatyti Frozen vertę
DocType: Payment Reconciliation,Get Unreconciled Entries,Gauk Unreconciled įrašai
DocType: Payment Reconciliation,From Invoice Date,Iš sąskaitos faktūros išrašymo data
DocType: Healthcare Settings,Laboratory Settings,Laboratoriniai nustatymai
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75,Leave Encashment,Palikite išgryninimo
apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,Ką tai daro?
DocType: Crop,Byproducts,Šalutiniai produktai
apps/erpnext/erpnext/stock/doctype/batch/batch.js +76,To Warehouse,į sandėlį
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26,All Student Admissions,Visi Studentų Priėmimo
,Average Commission Rate,Vidutinis Komisija Balsuok
apps/erpnext/erpnext/stock/doctype/item/item.py +434,'Has Serial No' can not be 'Yes' for non-stock item,&quot;Ar Serijos ne&quot; negali būti &quot;Taip&quot; už NON-STOCK punktą
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +62,Select Status,Pasirinkite būseną
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41,Attendance can not be marked for future dates,Dalyvavimas negali būti ženklinami ateities datas
DocType: Pricing Rule,Pricing Rule Help,Kainodaros taisyklė Pagalba
DocType: School House,House Name,Namas Vardas
DocType: Fee Schedule,Total Amount per Student,Bendra suma studentui
DocType: Purchase Taxes and Charges,Account Head,sąskaita vadovas
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153,Electrical,elektros
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,Pridėti jūsų organizacijos pailsėti kaip savo vartotojams. Taip pat galite pridėti kviečiame klientus į jūsų portalą pridedant juos nuo Kontaktai
DocType: Stock Entry,Total Value Difference (Out - In),Viso vertės skirtumas (iš - į)
DocType: Grant Application,Requested Amount,Prašoma suma
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +346,Row {0}: Exchange Rate is mandatory,Eilutės {0}: Valiutų kursai yra privalomi
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,User ID not set for Employee {0},Vartotojo ID nenustatyti Darbuotojo {0}
DocType: Vehicle,Vehicle Value,Automobilio Vertė
DocType: Crop Cycle,Detected Diseases,Aptikta ligų
DocType: Stock Entry,Default Source Warehouse,Numatytasis Šaltinis sandėlis
DocType: Item,Customer Code,Kliento kodas
apps/erpnext/erpnext/hr/doctype/employee/employee.py +220,Birthday Reminder for {0},Gimimo diena priminimas {0}
DocType: Asset Maintenance Task,Last Completion Date,Paskutinė užbaigimo data
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72,Days Since Last Order,Dienas nuo paskutinė užsakymo
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +352,Debit To account must be a Balance Sheet account,Debeto sąskaitą turi būti balansas sąskaitos
DocType: Buying Settings,Naming Series,Pavadinimų serija
DocType: Leave Block List,Leave Block List Name,Palikite blokuojamų sąrašą pavadinimas
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14,Insurance Start date should be less than Insurance End date,Draudimo pradžios data turėtų būti ne mažesnė nei draudimo pabaigos data
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Akcijų turtas
DocType: Timesheet,Production Detail,Gamybos detalės
DocType: Restaurant,Active Menu,Aktyvus meniu
DocType: Target Detail,Target Qty,Tikslinė Kiekis
DocType: Shopping Cart Settings,Checkout Settings,Vykdyti Nustatymai
DocType: Student Attendance,Present,Pateikti
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,Delivery Note {0} must not be submitted,Važtaraštis {0} negali būti pateikta
DocType: Notification Control,Sales Invoice Message,Pardavimų sąskaita faktūra pranešimas
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,Uždarymo Narystė {0} turi būti tipo atsakomybės / nuosavas kapitalas
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +325,Salary Slip of employee {0} already created for time sheet {1},Pajamos Kuponas darbuotojo {0} jau sukurta laiko lape {1}
DocType: Vehicle Log,Odometer,odometras
DocType: Sales Order Item,Ordered Qty,Užsakytas Kiekis
apps/erpnext/erpnext/stock/doctype/item/item.py +713,Item {0} is disabled,Prekė {0} yra išjungtas
DocType: Stock Settings,Stock Frozen Upto,Akcijų Šaldyti upto
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +929,BOM does not contain any stock item,BOM nėra jokių akcijų elementą
DocType: Chapter,Chapter Head,Skyrius vadovas
DocType: Payment Term,Month(s) after the end of the invoice month,Mėnuo (-os) po sąskaitos faktūros mėnesio pabaigos
apps/erpnext/erpnext/config/projects.py +19,Project activity / task.,Projekto veikla / užduotis.
DocType: Vehicle Log,Refuelling Details,Degalų detalės
apps/erpnext/erpnext/config/hr.py +104,Generate Salary Slips,Sukurti apie atlyginimų
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +44,"Buying must be checked, if Applicable For is selected as {0}","Ieško turi būti patikrinta, jei taikoma pasirinkta kaip {0}"
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,Nuolaida turi būti mažesnis nei 100
DocType: Shipping Rule,Restrict to Countries,Apriboti šalis
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +171,Select Delivery Notes,Pasirinkite pristatymo pastabas
DocType: Purchase Invoice,Write Off Amount (Company Currency),Nurašyti suma (Įmonės valiuta)
DocType: Sales Invoice Timesheet,Billing Hours,Atsiskaitymo laikas
DocType: Project,Total Sales Amount (via Sales Order),Bendra pardavimo suma (per pardavimo užsakymą)
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +529,Default BOM for {0} not found,Numatytasis BOM už {0} nerastas
apps/erpnext/erpnext/stock/doctype/item/item.py +489,Row #{0}: Please set reorder quantity,Eilutės # {0}: Prašome nustatyti pertvarkyti kiekį
apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,Bakstelėkite elementus įtraukti juos čia
DocType: Fees,Program Enrollment,programos Įrašas
DocType: Landed Cost Voucher,Landed Cost Voucher,Nusileido kaina čekis
apps/erpnext/erpnext/public/js/queries.js +39,Please set {0},Prašome nustatyti {0}
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} yra neaktyvus studentas
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} yra neaktyvus studentas
DocType: Employee,Health Details,sveikatos informacija
DocType: Offer Letter,Offer Letter Terms,Laiško su pasiūlymu Terminų
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,To create a Payment Request reference document is required,Norėdami sukurti mokėjimo prašymas nuoroda dokumentas yra reikalingas
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,To create a Payment Request reference document is required,Norėdami sukurti mokėjimo prašymas nuoroda dokumentas yra reikalingas
DocType: Soil Texture,Sandy Clay,Smėlio molis
DocType: Grant Application,Assessment  Manager,Vertinimo vadovas
DocType: Payment Entry,Allocate Payment Amount,Skirti mokėjimo suma
DocType: Employee External Work History,Salary,atlyginimas
DocType: Serial No,Delivery Document Type,Pristatymas Dokumento tipas
DocType: Sales Order,Partly Delivered,dalinai Paskelbta
DocType: Item Variant Settings,Do not update variants on save,Negalima atnaujinti išsaugojimo variantų
DocType: Email Digest,Receivables,gautinos sumos
DocType: Lead Source,Lead Source,Švinas Šaltinis
DocType: Customer,Additional information regarding the customer.,Papildoma informacija apie klientui.
DocType: Quality Inspection Reading,Reading 5,Skaitymas 5
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +225,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} susijęs su {2}, bet šalies sąskaita {3}"
apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7,View Lab Tests,Peržiūrėti laboratorijos bandymus
DocType: Purchase Invoice,Y,Y
DocType: Maintenance Visit,Maintenance Date,priežiūra data
DocType: Purchase Invoice Item,Rejected Serial No,Atmesta Serijos Nr
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,Metų pradžios datą arba pabaigos data sutampa su {0}. Norėdami išvengti nustatykite įmonę
apps/erpnext/erpnext/selling/doctype/customer/customer.py +108,Please mention the Lead Name in Lead {0},Prašome paminėti švino pavadinimą pirmaujančioje {0}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156,Start date should be less than end date for Item {0},Pradžios data turėtų būti mažesnis nei pabaigos datos punkte {0}
DocType: Item,"Example: ABCD.#####
If series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Pavyzdys:. ABCD ##### Jei serija yra nustatytas ir Serijos Nr nepaminėtas sandorius, tada automatinis serijos numeris bus sukurta remiantis šios serijos. Jei norite visada aiškiai paminėti eilės numeriai šią prekę nėra. Palikite šį lauką tuščią."
DocType: Upload Attendance,Upload Attendance,Įkelti Lankomumas
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +535,BOM and Manufacturing Quantity are required,BOM ir gamyba Kiekis yra privalomi
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Senėjimas klasės 2
DocType: SG Creation Tool Course,Max Strength,Maksimali jėga
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28,Installing presets,Iš anksto įdiegti
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +67,No Delivery Note selected for Customer {},Kliento pasirinkta pristatymo pastaba ()
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +22,BOM replaced,BOM pakeisti
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1041,Select Items based on Delivery Date,Pasirinkite elementus pagal pristatymo datą
DocType: Grant Application,Has any past Grant Record,Turi bet kokį ankstesnį &quot;Grant Record&quot;
,Sales Analytics,pardavimų Analytics &quot;
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +119,Available {0},Turimas {0}
,Prospects Engaged But Not Converted,Perspektyvos Užsiima Bet nevirsta
,Prospects Engaged But Not Converted,Perspektyvos Užsiima Bet nevirsta
DocType: Manufacturing Settings,Manufacturing Settings,Gamybos Nustatymai
apps/erpnext/erpnext/config/setup.py +56,Setting up Email,Įsteigti paštu
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Guardian1 Mobilus Nėra
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106,Please enter default currency in Company Master,Prašome įvesti numatytasis valiuta įmonėje Master
DocType: Stock Entry Detail,Stock Entry Detail,Akcijų įrašo informaciją
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109,Daily Reminders,Dienos Priminimai
DocType: Products Settings,Home Page is Products,Titulinis puslapis yra Produktai
,Asset Depreciation Ledger,Turto nusidėvėjimas Ledgeris
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +88,Tax Rule Conflicts with {0},Mokesčių taisyklė prieštarauja {0}
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,New Account Name,Nauja Sąskaitos pavadinimas
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Žaliavos Pateikiamas Kaina
DocType: Selling Settings,Settings for Selling Module,Nustatymai parduoti modulis
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115,Customer Service,Klientų aptarnavimas
DocType: BOM,Thumbnail,Miniatiūra
DocType: Item Customer Detail,Item Customer Detail,Prekė Klientų detalės
apps/erpnext/erpnext/config/hr.py +50,Offer candidate a Job.,Siūlau kandidatas darbą.
DocType: Notification Control,Prompt for Email on Submission of,Klausti Email pateikus
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88,Total allocated leaves are more than days in the period,Iš viso skiriami lapai yra daugiau nei laikotarpio dienų
DocType: Land Unit,Linked Soil Analysis,Susijusi dirvožemio analizė
DocType: Pricing Rule,Percentage,procentas
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70,Item {0} must be a stock Item,Prekė {0} turi būti akcijų punktas
DocType: Manufacturing Settings,Default Work In Progress Warehouse,Numatytasis nebaigtos Warehouse
apps/erpnext/erpnext/config/accounts.py +288,Default settings for accounting transactions.,Numatytieji nustatymai apskaitos operacijų.
DocType: Maintenance Visit,MV,V.
DocType: Restaurant,Default Tax Template,Numatytas mokesčio šablonas
DocType: Fees,Student Details,Studento duomenys
DocType: Purchase Invoice Item,Stock Qty,akcijų Kiekis
DocType: Purchase Invoice Item,Stock Qty,akcijų Kiekis
DocType: Employee Loan,Repayment Period in Months,Grąžinimo laikotarpis mėnesiais
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26,Error: Not a valid id?,Klaida: Negaliojantis tapatybės?
DocType: Naming Series,Update Series Number,Atnaujinti serijos numeris
DocType: Account,Equity,teisingumas
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: &quot;Pelno ir nuostolio&quot; tipo sąskaita {2} neleidžiama atidarymas įrašą
DocType: Sales Order,Printing Details,Spausdinimo detalės
DocType: Task,Closing Date,Pabaigos data
DocType: Sales Order Item,Produced Quantity,pagamintas kiekis
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126,Engineer,inžinierius
DocType: Journal Entry,Total Amount Currency,Bendra suma Valiuta
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Paieška Sub Agregatai
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171,Item Code required at Row No {0},Prekės kodas reikalaujama Row Nr {0}
DocType: GST Account,SGST Account,SGST sąskaita
apps/erpnext/erpnext/utilities/user_progress.py +151,Go to Items,Eiti į elementus
DocType: Sales Partner,Partner Type,partnerio tipas
DocType: Purchase Taxes and Charges,Actual,faktinis
DocType: Restaurant Menu,Restaurant Manager,Restorano vadybininkas
DocType: Authorization Rule,Customerwise Discount,Customerwise nuolaida
apps/erpnext/erpnext/config/projects.py +41,Timesheet for tasks.,Lapą užduotims.
DocType: Purchase Invoice,Against Expense Account,Prieš neskaičiuojantiems
DocType: Production Order,Production Order,Gamybos Užsakyti
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +273,Installation Note {0} has already been submitted,Įrengimas Pastaba {0} jau buvo pateikta
DocType: Bank Reconciliation,Get Payment Entries,Gauk Apmokėjimas įrašai
DocType: Quotation Item,Against Docname,prieš DOCNAME
DocType: SMS Center,All Employee (Active),Viskas Darbuotojų (aktyvus)
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Klientas&gt; Klientų grupė&gt; Teritorija
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9,View Now,peržiūrėti Dabar
DocType: BOM,Raw Material Cost,Žaliavų kaina
DocType: Item Reorder,Re-Order Level,Re įsakymu lygis
DocType: Production Planning Tool,Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,"Įveskite elementus ir planuojamą vnt, už kuriuos norite padidinti gamybos užsakymus arba atsisiųsti žaliavas analizė."
apps/erpnext/erpnext/projects/doctype/project/project.js +64,Gantt Chart,Ganto diagramos
DocType: Crop Cycle,Cycle Type,Ciklo tipas
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99,Part-time,Neakivaizdinės
DocType: Employee,Applicable Holiday List,Taikoma Atostogų sąrašas
DocType: Employee,Cheque,Tikrinti
DocType: Training Event,Employee Emails,Darbuotojų el. Laiškai
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +59,Series Updated,serija Atnaujinta
apps/erpnext/erpnext/accounts/doctype/account/account.py +159,Report Type is mandatory,Ataskaitos tipas yra privalomi
DocType: Item,Serial Number Series,Eilės numeris serija
apps/erpnext/erpnext/buying/utils.py +68,Warehouse is mandatory for stock Item {0} in row {1},Sandėlių yra privalomas akcijų punkte {0} iš eilės {1}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45,Retail & Wholesale,Mažmeninė prekyba ir didmeninė prekyba
DocType: Issue,First Responded On,Pirma atsakė
DocType: Website Item Group,Cross Listing of Item in multiple groups,"Kryžius, sąrašas elementą kelių grupių"
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},Fiskalinė metų pradžios data ir fiskalinių metų pabaigos data jau nustatyta fiskaliniais metais {0}
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Clearance Date updated,Atnaujintas klirensas data
apps/erpnext/erpnext/stock/doctype/batch/batch.js +138,Split Batch,Splitas Serija
apps/erpnext/erpnext/stock/doctype/batch/batch.js +138,Split Batch,Splitas Serija
DocType: Stock Settings,Batch Identification,Partijos identifikavimas
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +131,Successfully Reconciled,sėkmingai Suderinta
DocType: Request for Quotation Supplier,Download PDF,atsisiųsti PDF
DocType: Production Order,Planned End Date,Planuojamas Pabaigos data
apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Donoro tipo informacija.
DocType: Request for Quotation,Supplier Detail,tiekėjas detalės
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100,Error in formula or condition: {0},Klaida formulę ar būklės: {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +16,Invoiced Amount,Sąskaitoje suma
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47,Criteria weights must add up to 100%,Kriterijų svoriai turi sudaryti iki 100%
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,lankomumas
apps/erpnext/erpnext/public/js/pos/pos.html +104,Stock Items,atsargos
DocType: BOM,Materials,medžiagos
DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Jei nepažymėta, sąrašas turi būti pridedamas prie kiekvieno padalinio, kuriame jis turi būti taikomas."
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +103,Creating {0},Kūrimas {0}
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Originalo ir vertimo Sandėlis negali būti tas pats
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +566,Posting date and posting time is mandatory,Siunčiamos datą ir paskelbimo laiką yra privalomas
apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Mokesčių šablonas pirkti sandorius.
,Item Prices,Prekė Kainos
DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,"Žodžiais bus matomas, kai jūs išgelbėti pirkimo pavedimu."
DocType: Period Closing Voucher,Period Closing Voucher,Laikotarpis uždarymas čekis
DocType: Consultation,Review Details,Peržiūrėti detales
DocType: Dosage Form,Dosage Form,Dozavimo forma
apps/erpnext/erpnext/config/selling.py +67,Price List master.,Kainų sąrašas meistras.
DocType: Task,Review Date,peržiūros data
DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Turto nusidėvėjimo įrašas (žurnalo įrašas)
DocType: Membership,Member Since,Narys nuo
DocType: Purchase Invoice,Advance Payments,išankstiniai mokėjimai
DocType: Purchase Taxes and Charges,On Net Total,Dėl grynuosius
apps/erpnext/erpnext/controllers/item_variant.py +90,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Vertė Attribute {0} turi būti intervale {1} ir {2} į žingsniais {3} už prekę {4}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +171,Target warehouse in row {0} must be same as Production Order,"Tikslinė sandėlis {0} eilės turi būti toks pat, kaip gamybos ordino"
DocType: Restaurant Reservation,Waitlisted,Waitlisted
apps/erpnext/erpnext/accounts/doctype/account/account.py +124,Currency can not be changed after making entries using some other currency,"Valiuta negali būti pakeistas po to, kai įrašus naudojant kai kita valiuta"
DocType: Shipping Rule,Fixed,Fiksuotas
DocType: Vehicle Service,Clutch Plate,Sankabos diskas
DocType: Company,Round Off Account,Suapvalinti paskyrą
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93,Administrative Expenses,administracinės išlaidos
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18,Consulting,konsultavimas
DocType: Customer Group,Parent Customer Group,Tėvų Klientų grupė
DocType: Journal Entry,Subscription,Prenumerata
DocType: Purchase Invoice,Contact Email,kontaktinis elektroninio pašto adresas
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Mokesčio kūrimas laukiamas
DocType: Appraisal Goal,Score Earned,balas uždirbo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239,Notice Period,įspėjimo terminas
DocType: Asset Category,Asset Category Name,Turto Kategorijos pavadinimas
apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,This is a root territory and cannot be edited.,Tai yra šaknis teritorijoje ir negali būti pakeisti.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5,New Sales Person Name,Nauja pardavimų asmuo Vardas
DocType: Packing Slip,Gross Weight UOM,Bendras svoris UOM
DocType: Asset Maintenance Task,Preventive Maintenance,Profilaktinė priežiūra
DocType: Delivery Note Item,Against Sales Invoice,Prieš pardavimo sąskaita-faktūra
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151,Please enter serial numbers for serialized item ,Prašome įvesti serijinius numerius serializowanej prekę
DocType: Bin,Reserved Qty for Production,Reserved Kiekis dėl gamybos
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,"Palikite nepažymėtą jei nenorite atsižvelgti į partiją, o todėl kursų pagrįstas grupes."
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,"Palikite nepažymėtą jei nenorite atsižvelgti į partiją, o todėl kursų pagrįstas grupes."
DocType: Asset,Frequency of Depreciation (Months),Dažnio nusidėvėjimo (mėnesiais)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +501,Credit Account,Kreditinė sąskaita
DocType: Landed Cost Item,Landed Cost Item,Nusileido Kaina punktas
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57,Show zero values,Rodyti nulines vertes
DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Kiekis objekto gauti po gamybos / perpakavimas iš pateiktų žaliavų kiekius
DocType: Lab Test,Test Group,Bandymo grupė
DocType: Payment Reconciliation,Receivable / Payable Account,Gautinos / mokėtinos sąskaitos
DocType: Delivery Note Item,Against Sales Order Item,Prieš Pardavimų įsakymu punktas
apps/erpnext/erpnext/stock/doctype/item/item.py +680,Please specify Attribute Value for attribute {0},Prašome nurodyti Įgūdis požymio reikšmę {0}
DocType: Item,Default Warehouse,numatytasis sandėlis
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45,Budget cannot be assigned against Group Account {0},Biudžetas negali būti skiriamas prieš grupės sąskaitoje {0}
DocType: Healthcare Settings,Patient Registration,Paciento registracija
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22,Please enter parent cost center,Prašome įvesti patronuojanti kaštų centrą
DocType: Delivery Note,Print Without Amount,Spausdinti Be Suma
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57,Depreciation Date,Nusidėvėjimas data
DocType: Issue,Support Team,Palaikymo komanda
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36,Expiry (In Days),Galiojimo (dienomis)
DocType: Appraisal,Total Score (Out of 5),Iš viso balas (iš 5)
DocType: Fee Structure,FS.,FS.
DocType: Student Attendance Tool,Batch,Partija
DocType: Donor,Donor Type,Donoro tipas
apps/erpnext/erpnext/stock/doctype/item/item.js +27,Balance,balansas
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66,Please select the Company,Pasirinkite bendrovę
DocType: Room,Seating Capacity,Sėdimų vietų skaičius
DocType: Issue,ISS-,ISS-
DocType: Lab Test Groups,Lab Test Groups,Laboratorijos testų grupės
DocType: Project,Total Expense Claim (via Expense Claims),Bendras išlaidų pretenzija (per išlaidų paraiškos)
DocType: GST Settings,GST Summary,"Paaiškėjo, kad GST santrauka"
DocType: Assessment Result,Total Score,Galutinis rezultatas
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +116,Please set the Default Cost Center in {0} company,Nustatykite &quot;Numatytųjų kainų centro&quot; skaičių {0} kompanijoje
DocType: Journal Entry,Debit Note,debeto aviza
DocType: Stock Entry,As per Stock UOM,Kaip per vertybinių popierių UOM
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,nėra pasibaigęs
DocType: Student Log,Achievement,Pasiekimas
DocType: Batch,Source Document Type,Šaltinis Dokumento tipas
DocType: Batch,Source Document Type,Šaltinis Dokumento tipas
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24,Following course schedules were created,Buvo sukurti kursų tvarkaraščiai
DocType: Journal Entry,Total Debit,Iš viso Debeto
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Numatytieji gatavų prekių sandėlis
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76,Sales Person,Pardavėjas
apps/erpnext/erpnext/config/accounts.py +233,Budget and Cost Center,Biudžeto ir išlaidų centras
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65,Multiple default mode of payment is not allowed,Kelis numatytasis mokėjimo būdas neleidžiamas
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,for the,už
,Appointment Analytics,Paskyrimų analizė
DocType: Vehicle Service,Half Yearly,pusmečio
DocType: Lead,Blog Subscriber,Dienoraštis abonento
DocType: Guardian,Alternate Number,pakaitinis Taškų
DocType: Healthcare Settings,Consultations in valid days,Konsultacijos galiojančiomis dienomis
DocType: Assessment Plan Criteria,Maximum Score,Maksimalus balas
apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,"Sukurti taisykles, siekdama apriboti sandorius, pagrįstus vertybes."
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Grupė salė Nėra
DocType: Batch,Manufacturing Date,Pagaminimo data
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Mokesčio sukūrimas nepavyko
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Palikite tuščią, jei jūs padarote studentų grupes per metus"
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Palikite tuščią, jei jūs padarote studentų grupes per metus"
DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Jei pažymėta, viso nėra. darbo dienų bus atostogų, o tai sumažins Atlyginimas diena vertę"
DocType: Purchase Invoice,Total Advance,Iš viso Išankstinis
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27,Change Template Code,Pakeisti šablono kodą
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.,Kadencijos pabaigos data negali būti vėlesnė nei kadencijos pradžioje data. Ištaisykite datas ir bandykite dar kartą.
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,quot Grafas
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,quot Grafas
,BOM Stock Report,BOM sandėlyje ataskaita
DocType: Stock Reconciliation Item,Quantity Difference,kiekis skirtumas
DocType: Employee Advance,EA-,EA-
apps/erpnext/erpnext/config/hr.py +320,Processing Payroll,apdorojimo darbo užmokesčio
DocType: Opportunity Item,Basic Rate,bazinis tarifas
DocType: GL Entry,Credit Amount,kredito suma
DocType: Cheque Print Template,Signatory Position,signataras pozicijos
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175,Set as Lost,Nustatyti kaip Lost
DocType: Timesheet,Total Billable Hours,Iš viso apmokamas valandas
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,Mokėjimo kvitą Pastaba
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,Tai grindžiama sandorių atžvilgiu šis klientas. Žiūrėti grafikas žemiau detales
DocType: Company,Credit Days Based On,Kredito dienų remiantis
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +161,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Eilutės {0}: Paskirti suma {1} turi būti mažesnis arba lygus Mokėjimo Entry suma {2}
DocType: Program Enrollment Tool,New Academic Term,Naujas akademinis terminas
,Course wise Assessment Report,Žinoma protinga vertinimo ataskaita
DocType: Tax Rule,Tax Rule,mokesčių taisyklė
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Išlaikyti tą patį tarifą Kiaurai pardavimo ciklą
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Planuokite laiką rąstų lauko Workstation &quot;darbo valandomis.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +92,Dr {0} does not have a Physician Schedule. Add it in Physician master,Dr {0} neturi gydytojo tvarkaraščio. Pridėkite jį gydytojo kapitale
apps/erpnext/erpnext/public/js/pos/pos.html +87,Customers in Queue,Klientai eilėje
DocType: Driver,Issuing Date,Išleidimo data
DocType: Student,Nationality,Tautybė
,Items To Be Requested,"Daiktai, kurių bus prašoma"
DocType: Purchase Order,Get Last Purchase Rate,Gauk paskutinį pirkinį Balsuok
DocType: Company,Company Info,Įmonės informacija
apps/erpnext/erpnext/accounts/page/pos/pos.js +1375,Select or add new customer,Pasirinkite arba pridėti naujų klientų
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +179,Cost center is required to book an expense claim,Kaina centras privalo užsakyti sąnaudomis pretenziją
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Taikymas lėšos (turtas)
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,"Tai yra, remiantis šio darbuotojo dalyvavimo"
DocType: Assessment Result,Summary,Santrauka
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Pažymėti lankomumą
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +495,Debit Account,debeto sąskaita
DocType: Fiscal Year,Year Start Date,Metų pradžios data
DocType: Attendance,Employee Name,Darbuotojo vardas
DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Restorano užsakymo įrašas
DocType: Purchase Invoice,Rounded Total (Company Currency),Suapvalinti Iš viso (Įmonės valiuta)
apps/erpnext/erpnext/accounts/doctype/account/account.py +96,Cannot covert to Group because Account Type is selected.,"Negalima paslėptas į grupę, nes sąskaitos tipas yra pasirinktas."
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260,{0} {1} has been modified. Please refresh.,{0} {1} buvo pakeistas. Prašome atnaujinti.
DocType: Leave Block List,Stop users from making Leave Applications on following days.,Stop vartotojus nuo priėmimo prašymų įstoti į šių dienų.
DocType: Asset Maintenance Team,Maintenance Team Members,Techninės priežiūros komandos nariai
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63,Purchase Amount,pirkimo suma
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +259,Supplier Quotation {0} created,Tiekėjas Citata {0} sukūrė
apps/erpnext/erpnext/accounts/report/financial_statements.py +97,End Year cannot be before Start Year,Pabaiga metai bus ne anksčiau pradžios metus
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232,Employee Benefits,Išmokos darbuotojams
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +255,Packed quantity must equal quantity for Item {0} in row {1},Supakuotas kiekis turi vienodas kiekis už prekę {0} iš eilės {1}
DocType: Production Order,Manufactured Qty,pagaminta Kiekis
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64,Invoice Created,Sukurta sąskaita
DocType: Asset,Out of Order,Neveikia
DocType: Purchase Receipt Item,Accepted Quantity,Priimamos Kiekis
apps/erpnext/erpnext/hr/doctype/employee/employee.py +242,Please set a default Holiday List for Employee {0} or Company {1},Prašome nustatyti numatytąjį Atostogų sąrašas Darbuotojo {0} arba Įmonės {1}
apps/erpnext/erpnext/accounts/party.py +31,{0}: {1} does not exists,{0}: {1} neegzistuoja
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76,Select Batch Numbers,Pasirinkite partijų numeriai
apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Vekseliai iškelti į klientams.
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,Projektų ID
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +532,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Eilutės Nėra {0}: suma negali būti didesnė nei Kol Suma prieš expense punktą {1}. Kol suma yra {2}
DocType: Assessment Plan,Schedule,grafikas
DocType: Account,Parent Account,tėvų paskyra
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266,Available,pasiekiamas
DocType: Quality Inspection Reading,Reading 3,Skaitymas 3
,Hub,įvorė
DocType: GL Entry,Voucher Type,Bon tipas
apps/erpnext/erpnext/accounts/page/pos/pos.js +1707,Price List not found or disabled,Kainų sąrašas nerastas arba išjungtas
DocType: Student Applicant,Approved,patvirtinta
DocType: Pricing Rule,Price,kaina
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +266,Employee relieved on {0} must be set as 'Left',Darbuotojų atleidžiamas nuo {0} turi būti nustatyti kaip &quot;Left&quot;
DocType: Hub Settings,Last Sync On,Paskutinė sinchronizacija įjungta
DocType: Guardian,Guardian,globėjas
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,Vertinimas {0} sukurtas darbuotojo {1} konkrečioje dat
DocType: Academic Term,Education,švietimas
apps/erpnext/erpnext/public/js/pos/pos.html +78,Del,del
DocType: Selling Settings,Campaign Naming By,Kampanija įvardijimas Iki
DocType: Employee,Current Address Is,Dabartinis adresas
apps/erpnext/erpnext/utilities/user_progress.py +48,Monthly Sales Target (,Mėnesio pardavimo tikslai (
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,keistas
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43,"Optional. Sets company's default currency, if not specified.","Neprivaloma. Nustato įmonės numatytasis valiuta, jeigu nenurodyta."
DocType: Sales Invoice,Customer GSTIN,Klientų 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 ,"Lauke aptiktų ligų sąrašas. Pasirinkus, jis bus automatiškai pridėti užduočių sąrašą kovai su liga"
DocType: Asset Repair,Repair Status,Taisyklės būklė
apps/erpnext/erpnext/config/accounts.py +67,Accounting journal entries.,Apskaitos žurnalo įrašai.
DocType: Delivery Note Item,Available Qty at From Warehouse,Turimas Kiekis ne iš sandėlio
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +327,Please select Employee Record first.,Prašome pasirinkti Darbuotojų įrašai pirmą kartą.
DocType: POS Profile,Account for Change Amount,Sąskaita už pokyčio sumą
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +215,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Eilutės {0}: Šalis / Sąskaita nesutampa su {1} / {2} į {3} {4}
DocType: Maintenance Team Member,Maintenance Team Member,Techninės priežiūros komandos narys
DocType: Agriculture Analysis Criteria,Soil Analysis,Dirvožemio analizė
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Course Code: ,Modulio kodas:
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240,Please enter Expense Account,Prašome įvesti sąskaita paskyrą
DocType: Account,Stock,ištekliai
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1068,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Eilutės # {0}: Informacinis dokumentas tipas turi būti vienas iš pirkimo tvarka, pirkimo sąskaitoje faktūroje ar žurnalo įrašą"
DocType: Employee,Current Address,Dabartinis adresas
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","Jei elementas yra kito elemento, tada aprašymas, vaizdo, kainodara, mokesčiai ir tt bus nustatytas nuo šablono variantas, nebent aiškiai nurodyta"
DocType: Serial No,Purchase / Manufacture Details,Pirkimas / Gamyba detalės
DocType: Assessment Group,Assessment Group,vertinimo grupė
apps/erpnext/erpnext/config/stock.py +325,Batch Inventory,Serija Inventorius
DocType: Employee,Contract End Date,Sutarties pabaigos data
DocType: Sales Order,Track this Sales Order against any Project,Sekti šią pardavimų užsakymų prieš bet kokį projektą
DocType: Sales Invoice Item,Discount and Margin,Nuolaida ir Marža
DocType: Lab Test,Prescription,Receptas
DocType: Production Planning Tool,Pull sales orders (pending to deliver) based on the above criteria,"Pull pardavimo užsakymus (kol pristatyti), remiantis minėtais kriterijais"
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +98,Not Available,Nepasiekiamas
DocType: Pricing Rule,Min Qty,min Kiekis
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36,Disable Template,Išjungti šabloną
DocType: GL Entry,Transaction Date,Operacijos data
DocType: Production Plan Item,Planned Qty,Planuojamas Kiekis
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Iš viso Mokesčių
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +187,For Quantity (Manufactured Qty) is mandatory,Dėl Kiekis (Pagaminta Kiekis) yra privalomi
DocType: Stock Entry,Default Target Warehouse,Numatytasis Tikslinė sandėlis
DocType: Purchase Invoice,Net Total (Company Currency),Grynasis viso (Įmonės valiuta)
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.,Dienos iki metų pabaigos data negali būti vėlesnė nei metų pradžioje data. Ištaisykite datas ir bandykite dar kartą.
DocType: Notification Control,Purchase Receipt Message,Pirkimo kvito pranešimas
DocType: BOM,Scrap Items,laužas daiktai
DocType: Production Order,Actual Start Date,Tikrasis pradžios data
DocType: Sales Order,% of materials delivered against this Sales Order,% Medžiagų pristatytas prieš šią pardavimų užsakymų
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62,Set default mode of payment,Nustatykite numatytą mokėjimo būdą
DocType: Grant Application,Withdrawn,panaikintas
DocType: Hub Settings,Hub Settings,Hub Nustatymai
DocType: Project,Gross Margin %,"Bendroji marža,%"
DocType: BOM,With Operations,su operacijų
apps/erpnext/erpnext/accounts/party.py +262,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Apskaitos įrašai jau buvo padaryta valiuta {0} kompanijai {1}. Prašome pasirinkti gautinai ar mokėtinai sumai sąskaitą valiuta {0}.
DocType: Asset,Is Existing Asset,Ar turimo turto
DocType: Salary Detail,Statistical Component,Statistiniai komponentas
DocType: Salary Detail,Statistical Component,Statistiniai komponentas
DocType: Warranty Claim,If different than customer address,"Jei kitoks, nei klientų adresą"
DocType: Purchase Invoice,Without Payment of Tax,Nemokant mokesčio
DocType: BOM Operation,BOM Operation,BOM operacija
apps/erpnext/erpnext/config/stock.py +141,Fulfilment,Įvykdymas
DocType: Purchase Taxes and Charges,On Previous Row Amount,Dėl ankstesnės eilės Suma
DocType: Item,Has Expiry Date,Turi galiojimo datą
apps/erpnext/erpnext/assets/doctype/asset/asset.js +269,Transfer Asset,perduoto turto
DocType: POS Profile,POS Profile,POS profilis
DocType: Training Event,Event Name,Įvykio pavadinimas
DocType: Physician,Phone (Office),Telefonas (biuras)
apps/erpnext/erpnext/hooks.py +151,Admission,priėmimas
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29,Admissions for {0},Priėmimo dėl {0}
apps/erpnext/erpnext/config/accounts.py +257,"Seasonality for setting budgets, targets etc.","Sezoniškumas nustatymo biudžetai, tikslai ir tt"
DocType: Supplier Scorecard Scoring Variable,Variable Name,Kintamasis pavadinimas
apps/erpnext/erpnext/stock/get_item_details.py +142,"Item {0} is a template, please select one of its variants","Prekė {0} yra šablonas, prašome pasirinkti vieną iš jo variantai"
DocType: Asset,Asset Category,turto Kategorija
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31,Net pay cannot be negative,Neto darbo užmokestis negali būti neigiamas
DocType: Purchase Order,Advance Paid,sumokėto avanso
DocType: Item,Item Tax,Prekė Mokesčių
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +872,Material to Supplier,"Medžiaga, iš Tiekėjui"
DocType: Soil Texture,Loamy Sand,Gluosnių smėlis
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +594,Excise Invoice,akcizo Sąskaita
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Treshold {0}% atrodo daugiau nei vieną kartą
DocType: Expense Claim,Employees Email Id,Darbuotojai elektroninio pašto numeris
DocType: Employee Attendance Tool,Marked Attendance,Pažymėti Lankomumas
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138,Current Liabilities,Dabartiniai įsipareigojimai
apps/erpnext/erpnext/config/selling.py +292,Send mass SMS to your contacts,Siųsti masės SMS į jūsų kontaktus
DocType: Patient,A Positive,Teigiamas
DocType: Program,Program Name,programos pavadinimas
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Apsvarstykite mokestį arba rinkliavą už
DocType: Driver,Driving License Category,Vairuotojo pažymėjimo kategorija
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Tikrasis Kiekis yra privalomi
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +88,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.","{0} šiuo metu turi {1} tiekėjų rezultatų kortelę, o šio tiekėjo pirkimo užsakymai turėtų būti išduodami atsargiai."
DocType: Asset Maintenance Team,Asset Maintenance Team,Turto priežiūros komanda
DocType: Employee Loan,Loan Type,paskolos tipas
DocType: Scheduling Tool,Scheduling Tool,planavimas įrankis
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180,Credit Card,Kreditinė kortelė
DocType: BOM,Item to be manufactured or repacked,Prekė turi būti pagaminti arba perpakuoti
DocType: Employee Education,Major/Optional Subjects,Pagrindinės / Laisvai pasirenkami dalykai
DocType: Sales Invoice Item,Drop Ship,Drop Ship
DocType: Driver,Suspended,Sustabdyta
DocType: Training Event,Attendees,Dalyviai
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Čia galite išsaugoti šeimos detalės, pavyzdžiui, pavadinimą ir okupacijos patronuojančią įmonę, sutuoktiniui ir vaikams"
DocType: Academic Term,Term End Date,Kadencijos pabaigos data
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Mokesčiai ir rinkliavos Išskaityta (Įmonės valiuta)
DocType: Item Group,General Settings,Bendrieji nustatymai
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23,From Currency and To Currency cannot be same,Nuo Valiuta ir valiutos negali būti tas pats
DocType: Stock Entry,Repack,Iš naujo supakuokite
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,Jūs turite išgelbėti prieš tęsdami formą
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113,Please select the Company first,Pirmiausia pasirinkite kompaniją
DocType: Item Attribute,Numeric Values,reikšmes
apps/erpnext/erpnext/public/js/setup_wizard.js +56,Attach Logo,prisegti logotipas
apps/erpnext/erpnext/stock/doctype/batch/batch.js +43,Stock Levels,atsargų kiekis
DocType: Customer,Commission Rate,Komisija Balsuok
apps/erpnext/erpnext/stock/doctype/item/item.js +473,Make Variant,Padaryti variantas
apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Blokuoti atostogų prašymai departamento.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +144,"Payment Type must be one of Receive, Pay and Internal Transfer",Mokėjimo tipas turi būti vienas iš Gauti Pay ir vidaus perkėlimo
apps/erpnext/erpnext/config/selling.py +179,Analytics,Google Analytics
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +21,Cart is Empty,Krepšelis tuščias
DocType: Vehicle,Model,Modelis
DocType: Production Order,Actual Operating Cost,Tikrasis eksploatavimo išlaidos
DocType: Payment Entry,Cheque/Reference No,Čekis / Nuorodos Nr
DocType: Soil Texture,Clay Loam,Clay Loam
apps/erpnext/erpnext/accounts/doctype/account/account.py +81,Root cannot be edited.,Šaknų negali būti redaguojami.
DocType: Item,Units of Measure,Matavimo vienetai
DocType: Manufacturing Settings,Allow Production on Holidays,Leiskite gamyba Šventės
DocType: Sales Order,Customer's Purchase Order Date,Kliento Užsakymo data
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163,Capital Stock,Kapitalas
DocType: Shopping Cart Settings,Show Public Attachments,Rodyti Viešieji Priedai
DocType: Packing Slip,Package Weight Details,Pakuotės svoris detalės
DocType: Restaurant Reservation,Reservation Time,Rezervacijos laikas
DocType: Payment Gateway Account,Payment Gateway Account,Mokėjimo šliuzai paskyra
DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Po mokėjimo pabaigos nukreipti vartotoją į pasirinktame puslapyje.
DocType: Company,Existing Company,Esama Įmonės
DocType: Healthcare Settings,Result Emailed,Rezultatas išsiųstas el. Paštu
apps/erpnext/erpnext/controllers/buying_controller.py +87,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Mokesčių Kategorija buvo pakeistas į &quot;Total&quot;, nes visi daiktai yra ne atsargos"
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103,Please select a csv file,Prašome pasirinkti CSV failą
DocType: Student Leave Application,Mark as Present,Žymėti kaip dabartis
DocType: Supplier Scorecard,Indicator Color,Rodiklio spalva
DocType: Purchase Order,To Receive and Bill,Gauti ir Bill
apps/erpnext/erpnext/controllers/buying_controller.py +455,Row #{0}: Reqd by Date cannot be before Transaction Date,Eilutė # {0}: Reqd pagal datą negali būti prieš Transakcijos datą
apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,Panašūs produktai
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136,Designer,dizaineris
apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Terminai ir sąlygos Šablono
DocType: Serial No,Delivery Details,Pristatymo informacija
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +495,Cost Center is required in row {0} in Taxes table for type {1},Kaina centras reikalingas eilės {0} mokesčių lentelė tipo {1}
DocType: Program,Program Code,programos kodas
DocType: Terms and Conditions,Terms and Conditions Help,Terminai ir sąlygos Pagalba
,Item-wise Purchase Register,Prekė išmintingas pirkimas Registruotis
DocType: Driver,Expiry Date,Galiojimo data
DocType: Healthcare Settings,Employee name and designation in print,Darbuotojo vardas ir pavardė spaudoje
,accounts-browser,sąskaitos-naršyklė
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368,Please select Category first,Prašome pasirinkti Kategorija pirmas
apps/erpnext/erpnext/config/projects.py +13,Project master.,Projektų meistras.
apps/erpnext/erpnext/controllers/status_updater.py +209,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.","Leisti per sąskaitų arba per užsakymą, atnaujinti &quot;pašalpa&quot; sandėlyje nustatymus arba elementą."
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Nerodyti kaip $ ir tt simbolis šalia valiutomis.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +491, (Half Day),(Pusė dienos)
DocType: Payment Term,Credit Days,kredito dienų
apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Padaryti Studentų Serija
DocType: Fee Schedule,FRQ.,FRQ.
DocType: Leave Type,Is Carry Forward,Ar perkelti
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +840,Get Items from BOM,Gauti prekes iš BOM
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Švinas Laikas dienas
apps/erpnext/erpnext/controllers/accounts_controller.py +620,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Eilutės # {0}: Siunčiamos data turi būti tokia pati kaip pirkimo datos {1} Turto {2}
DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,"Pažymėkite, jei tas studentas gyvena institute bendrabutyje."
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125,Please enter Sales Orders in the above table,Prašome įvesti pardavimų užsakymų pirmiau pateiktoje lentelėje
,Stock Summary,akcijų santrauka
apps/erpnext/erpnext/config/assets.py +50,Transfer an asset from one warehouse to another,Perduoti turtą iš vieno sandėlio į kitą
DocType: Vehicle,Petrol,benzinas
apps/erpnext/erpnext/config/learn.py +217,Bill of Materials,Sąmata
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +103,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Eilutės {0}: Šalis tipas ir partijos reikalingas gautinos / mokėtinos sąskaitos {1}
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94,Ref Date,teisėjas data
DocType: Employee,Reason for Leaving,Išvykimo priežastis
DocType: BOM Operation,Operating Cost(Company Currency),Operacinė Kaina (Įmonės valiuta)
DocType: Employee Loan Application,Rate of Interest,Palūkanų norma
DocType: Expense Claim Detail,Sanctioned Amount,sankcijos suma
DocType: Item,Shelf Life In Days,Tinkamumo laikas dienomis
DocType: GL Entry,Is Opening,Ar atidarymas
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +194,Row {0}: Debit entry can not be linked with a {1},Eilutės {0}: debeto įrašą negali būti susieta su {1}
DocType: Journal Entry,Subscription Section,Prenumeratos skyrius
apps/erpnext/erpnext/accounts/doctype/account/account.py +177,Account {0} does not exist,Sąskaita {0} neegzistuoja
DocType: Training Event,Training Program,Treniravimosi programa
DocType: Account,Cash,pinigai
DocType: Employee,Short biography for website and other publications.,Trumpa biografija interneto svetainės ir kitų leidinių.
